@typeberry/lib 0.2.0-c96e8ef → 0.2.0-eae807e

package/index.js

@@ -1,50 +1,47 @@
 import assert from 'node:assert';
-import fs from 'node:fs';
+import fs, { readFileSync } from 'node:fs';
 import os from 'node:os';
+import { fileURLToPath } from 'node:url';
 
 var GpVersion;
 (function (GpVersion) {
     GpVersion["V0_6_7"] = "0.6.7";
     GpVersion["V0_7_0"] = "0.7.0";
     GpVersion["V0_7_1"] = "0.7.1";
-    GpVersion["V0_7_2"] = "0.7.2-preview";
+    GpVersion["V0_7_2"] = "0.7.2";
 })(GpVersion || (GpVersion = {}));
 var TestSuite;
 (function (TestSuite) {
     TestSuite["W3F_DAVXY"] = "w3f-davxy";
     TestSuite["JAMDUNA"] = "jamduna";
 })(TestSuite || (TestSuite = {}));
+const ALL_VERSIONS_IN_ORDER = [GpVersion.V0_6_7, GpVersion.V0_7_0, GpVersion.V0_7_1, GpVersion.V0_7_2];
 const DEFAULT_SUITE = TestSuite.W3F_DAVXY;
-const DEFAULT_VERSION = GpVersion.V0_7_1;
+const DEFAULT_VERSION = GpVersion.V0_7_2;
 const env$1 = typeof process === "undefined" ? {} : process.env;
 let CURRENT_VERSION = parseCurrentVersion(env$1.GP_VERSION) ?? DEFAULT_VERSION;
 let CURRENT_SUITE = parseCurrentSuite(env$1.TEST_SUITE) ?? DEFAULT_SUITE;
-const ALL_VERSIONS_IN_ORDER = [GpVersion.V0_6_7, GpVersion.V0_7_0, GpVersion.V0_7_1, GpVersion.V0_7_2];
 function parseCurrentVersion(env) {
     if (env === undefined) {
         return undefined;
     }
-    switch (env) {
-        case GpVersion.V0_6_7:
-        case GpVersion.V0_7_0:
-        case GpVersion.V0_7_1:
-        case GpVersion.V0_7_2:
-            return env;
-        default:
-            throw new Error(`Configured environment variable GP_VERSION is unknown: '${env}'. Use one of: ${ALL_VERSIONS_IN_ORDER}`);
+    for (const v of Object.values(GpVersion)) {
+        if (env === v) {
+            return v;
+        }
     }
+    throw new Error(`Configured environment variable GP_VERSION is unknown: '${env}'. Use one of: ${ALL_VERSIONS_IN_ORDER}`);
 }
 function parseCurrentSuite(env) {
     if (env === undefined) {
         return undefined;
     }
-    switch (env) {
-        case TestSuite.W3F_DAVXY:
-        case TestSuite.JAMDUNA:
-            return env;
-        default:
-            throw new Error(`Configured environment variable TEST_SUITE is unknown: '${env}'. Use one of: ${Object.values(TestSuite)}`);
+    for (const s of Object.values(TestSuite)) {
+        if (env === s) {
+            return s;
+        }
     }
+    throw new Error(`Configured environment variable TEST_SUITE is unknown: '${env}'. Use one of: ${Object.values(TestSuite)}`);
 }
 class Compatibility {
     static override(version) {
@@ -5171,6 +5168,17 @@ class Bootnode {
     }
 }
 
+/** Implemented PVM Backends names in THE SAME ORDER as enum. */
+const PvmBackendNames = ["built-in", "ananas"];
+/** Implemented PVM Backends to choose from. */
+var PvmBackend;
+(function (PvmBackend) {
+    /** Built-in aka. Typeberry 🫐 interpreter. */
+    PvmBackend[PvmBackend["BuiltIn"] = 0] = "BuiltIn";
+    /** Ananas 🍍 interpreter. */
+    PvmBackend[PvmBackend["Ananas"] = 1] = "Ananas";
+})(PvmBackend || (PvmBackend = {}));
+
 var index$m = /*#__PURE__*/Object.freeze({
   __proto__: null,
   Bootnode: Bootnode,
@@ -5180,6 +5188,8 @@ var index$m = /*#__PURE__*/Object.freeze({
   EST_EPOCH_LENGTH: EST_EPOCH_LENGTH,
   EST_VALIDATORS: EST_VALIDATORS,
   EST_VALIDATORS_SUPER_MAJORITY: EST_VALIDATORS_SUPER_MAJORITY,
+  get PvmBackend () { return PvmBackend; },
+  PvmBackendNames: PvmBackendNames,
   fullChainSpec: fullChainSpec,
   tinyChainSpec: tinyChainSpec
 });
@@ -7728,6 +7738,7 @@ const DEFAULT_CONFIG = "default";
 const NODE_DEFAULTS = {
     name: isBrowser() ? "browser" : os.hostname(),
     config: DEFAULT_CONFIG,
+    pvm: PvmBackend.BuiltIn,
 };
 /** Chain spec chooser. */
 var KnownChainSpec;
@@ -10927,6 +10938,13 @@ class StateEntries {
     [TEST_COMPARE_USING]() {
         return Object.fromEntries(this.entries);
     }
+    /** Dump state entries to JSON string (format compatible with stf vectors). */
+    toString() {
+        return JSON.stringify(Array.from(this.entries.entries()).map(([key, value]) => ({
+            key,
+            value,
+        })), null, 2);
+    }
     [Symbol.iterator]() {
         return this.entries[Symbol.iterator]();
     }
@@ -12270,18 +12288,41 @@ class PendingTransfer {
     }
 }
 
+/** Attempt to convert given number into U32 gas representation. */
+const tryAsSmallGas = (v) => asOpaqueType(tryAsU32(v));
+/** Attempt to convert given number into U64 gas representation. */
+const tryAsBigGas = (v) => asOpaqueType(tryAsU64(v));
+/** Attempt to convert given number into gas. */
+const tryAsGas = (v) => typeof v === "number" && v < 2 ** 32 ? tryAsSmallGas(v) : tryAsBigGas(v);
+
+const MAX_MEMORY_INDEX = 0xffff_ffff;
+const MEMORY_SIZE = MAX_MEMORY_INDEX + 1;
+const PAGE_SIZE_SHIFT$1 = 12;
+function getPageStartAddress(address) {
+    return tryAsU32(((address >>> PAGE_SIZE_SHIFT$1) << PAGE_SIZE_SHIFT$1) >>> 0);
+}
+
+const NO_OF_REGISTERS$1 = 13;
+const REGISTER_BYTE_SIZE = 8;
+
 /**
- * Inner status codes for the PVM
+ * Result codes for the PVM execution.
  *
- * https://graypaper.fluffylabs.dev/#/85129da/2cae022cae02?v=0.6.3
+ * https://graypaper.fluffylabs.dev/#/ab2cdbd/2e43002e4300?v=0.7.2
  */
 var Status;
 (function (Status) {
+    /** Continue */
     Status[Status["OK"] = 255] = "OK";
+    /** Finished */
     Status[Status["HALT"] = 0] = "HALT";
+    /** Panic */
     Status[Status["PANIC"] = 1] = "PANIC";
+    /** Page-fault */
     Status[Status["FAULT"] = 2] = "FAULT";
+    /** Host-call */
     Status[Status["HOST"] = 3] = "HOST";
+    /** Out of gas */
     Status[Status["OOG"] = 4] = "OOG";
 })(Status || (Status = {}));
 
@@ -12678,6 +12719,9 @@ function writeServiceIdAsLeBytes(serviceId, destination) {
 function clampU64ToU32(value) {
     return value > MAX_U32_BIG_INT ? MAX_U32 : tryAsU32(Number(value));
 }
+function emptyRegistersBuffer() {
+    return safeAllocUint8Array(NO_OF_REGISTERS$1 * REGISTER_BYTE_SIZE);
+}
 
 var index$9 = /*#__PURE__*/Object.freeze({
   __proto__: null,
@@ -12706,6 +12750,7 @@ var index$9 = /*#__PURE__*/Object.freeze({
   get UpdatePrivilegesError () { return UpdatePrivilegesError; },
   get ZeroVoidError () { return ZeroVoidError; },
   clampU64ToU32: clampU64ToU32,
+  emptyRegistersBuffer: emptyRegistersBuffer,
   getServiceId: getServiceId,
   getServiceIdOrCurrent: getServiceIdOrCurrent,
   slotsToPreimageStatus: slotsToPreimageStatus,
@@ -12837,8 +12882,7 @@ var index$8 = /*#__PURE__*/Object.freeze({
   MerkleMountainRange: MerkleMountainRange
 });
 
-const NO_OF_REGISTERS$1 = 13;
-const REGISTER_SIZE_SHIFT = 3;
+const REGISTER_SIZE_SHIFT = 3; // x << 3 === x * 8
 const tryAsRegisterIndex = (index) => {
     check `${index >= 0 && index < NO_OF_REGISTERS$1} Incorrect register index: ${index}!`;
     return asOpaqueType(index);
@@ -12853,6 +12897,13 @@ class Registers {
         this.asSigned = new BigInt64Array(bytes.buffer, bytes.byteOffset);
         this.asUnsigned = new BigUint64Array(bytes.buffer, bytes.byteOffset);
     }
+    getAllEncoded() {
+        return this.bytes;
+    }
+    setAllEncoded(bytes) {
+        check `${bytes.length === this.bytes.length} Incorrect size of input registers. Got: ${bytes.length}, need: ${this.bytes.length}`;
+        this.bytes.set(bytes, 0);
+    }
     static fromBytes(bytes) {
         check `${bytes.length === NO_OF_REGISTERS$1 << REGISTER_SIZE_SHIFT} Invalid size of registers array.`;
         return new Registers(bytes);
@@ -12861,9 +12912,6 @@ class Registers {
         const offset = index << REGISTER_SIZE_SHIFT;
         return this.bytes.subarray(offset, offset + len);
     }
-    getAllBytesAsLittleEndian() {
-        return this.bytes;
-    }
     copyFrom(regs) {
         const array = regs instanceof BigUint64Array ? regs : regs.asUnsigned;
         this.asUnsigned.set(array);
@@ -12935,20 +12983,222 @@ function traceRegisters(...regs) {
     return regs.map(tryAsRegisterIndex);
 }
 
-/** Attempt to convert given number into U32 gas representation. */
-const tryAsSmallGas = (v) => asOpaqueType(tryAsU32(v));
-/** Attempt to convert given number into U64 gas representation. */
-const tryAsBigGas = (v) => asOpaqueType(tryAsU64(v));
-/** Attempt to convert given number into gas. */
-const tryAsGas = (v) => typeof v === "number" && v < 2 ** 32 ? tryAsSmallGas(v) : tryAsBigGas(v);
+class HostCallMemory {
+    memory;
+    constructor(memory) {
+        this.memory = memory;
+    }
+    /**
+     * Save some bytes into memory under given address.
+     *
+     * NOTE: Given address is U64 (pure register value),
+     * but we use only lower 32-bits.
+     */
+    storeFrom(regAddress, bytes) {
+        if (bytes.length === 0) {
+            return Result$1.ok(OK);
+        }
+        // NOTE: We always take lower 32 bits from register value.
+        //
+        // https://graypaper.fluffylabs.dev/#/ab2cdbd/25ed0025ed00?v=0.7.2
+        const address = tryAsU32(Number(regAddress & 0xffffffffn));
+        return this.memory.store(address, bytes);
+    }
+    /**
+     * Read some bytes from memory under given address.
+     *
+     * NOTE: Given address is U64 (pure register value),
+     * but we use only lower 32-bits.
+     */
+    loadInto(output, regAddress) {
+        if (output.length === 0) {
+            return Result$1.ok(OK);
+        }
+        // https://graypaper.fluffylabs.dev/#/ab2cdbd/25ed0025ed00?v=0.7.2
+        //
+        // NOTE we are taking the the lower U32 part of the register, hence it's safe.
+        const address = tryAsU32(Number(regAddress & 0xffffffffn));
+        return this.memory.read(address, output);
+    }
+}
+
+class HostCallRegisters {
+    bytes;
+    registers;
+    constructor(bytes) {
+        this.bytes = bytes;
+        this.registers = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    }
+    /** Get U64 register value. */
+    get(registerIndex) {
+        return tryAsU64(this.registers.getBigUint64(registerIndex * REGISTER_BYTE_SIZE, true));
+    }
+    /** Set U64 register value. */
+    set(registerIndex, value) {
+        this.registers.setBigUint64(registerIndex * REGISTER_BYTE_SIZE, value, true);
+    }
+    /** Get all registers encoded into little-endian bytes. */
+    getEncoded() {
+        return this.bytes;
+    }
+}
+
+class ReturnValue {
+    consumedGas;
+    status;
+    memorySlice;
+    constructor(consumedGas, status, memorySlice) {
+        this.consumedGas = consumedGas;
+        this.status = status;
+        this.memorySlice = memorySlice;
+        check `
+      ${(status === null && memorySlice !== null) || (status !== null && memorySlice === null)}
+      'status' and 'memorySlice' must not both be null or both be non-null — exactly one must be provided
+    `;
+    }
+    static fromStatus(consumedGas, status) {
+        return new ReturnValue(consumedGas, status, null);
+    }
+    static fromMemorySlice(consumedGas, memorySlice) {
+        return new ReturnValue(consumedGas, null, memorySlice);
+    }
+    hasMemorySlice() {
+        return this.memorySlice instanceof Uint8Array && this.status === null;
+    }
+    hasStatus() {
+        return !this.hasMemorySlice();
+    }
+}
+class HostCalls {
+    pvmInstanceManager;
+    hostCalls;
+    constructor(pvmInstanceManager, hostCalls) {
+        this.pvmInstanceManager = pvmInstanceManager;
+        this.hostCalls = hostCalls;
+    }
+    getReturnValue(status, pvmInstance) {
+        const gasConsumed = pvmInstance.gas.used();
+        if (status === Status.OOG) {
+            return ReturnValue.fromStatus(gasConsumed, status);
+        }
+        if (status === Status.HALT) {
+            const regs = new HostCallRegisters(pvmInstance.registers.getAllEncoded());
+            const memory = new HostCallMemory(pvmInstance.memory);
+            const address = regs.get(7);
+            // NOTE we are taking the the lower U32 part of the register, hence it's safe.
+            const length = Number(regs.get(8) & 0xffffffffn);
+            const result = safeAllocUint8Array(length);
+            const loadResult = memory.loadInto(result, address);
+            if (loadResult.isError) {
+                return ReturnValue.fromMemorySlice(gasConsumed, new Uint8Array());
+            }
+            return ReturnValue.fromMemorySlice(gasConsumed, result);
+        }
+        return ReturnValue.fromStatus(gasConsumed, Status.PANIC);
+    }
+    async execute(pvmInstance) {
+        pvmInstance.runProgram();
+        for (;;) {
+            let status = pvmInstance.getStatus();
+            if (status !== Status.HOST) {
+                return this.getReturnValue(status, pvmInstance);
+            }
+            check `
+        ${pvmInstance.getExitParam() !== null}
+        "We know that the exit param is not null, because the status is 'Status.HOST'
+      `;
+            const hostCallIndex = pvmInstance.getExitParam() ?? -1;
+            const gas = pvmInstance.gas;
+            const regs = new HostCallRegisters(pvmInstance.registers.getAllEncoded());
+            const memory = new HostCallMemory(pvmInstance.memory);
+            const index = tryAsHostCallIndex(hostCallIndex);
+            const hostCall = this.hostCalls.get(index);
+            const gasBefore = gas.get();
+            // NOTE: `basicGasCost(regs)` function is for compatibility reasons: pre GP 0.7.2
+            const basicGasCost = typeof hostCall.basicGasCost === "number" ? hostCall.basicGasCost : hostCall.basicGasCost(regs);
+            const underflow = gas.sub(basicGasCost);
+            const pcLog = `[PC: ${pvmInstance.getPC()}]`;
+            if (underflow) {
+                this.hostCalls.traceHostCall(`${pcLog} OOG`, index, hostCall, regs, gas.get());
+                return ReturnValue.fromStatus(gas.used(), Status.OOG);
+            }
+            this.hostCalls.traceHostCall(`${pcLog} Invoking`, index, hostCall, regs, gasBefore);
+            const result = await hostCall.execute(gas, regs, memory);
+            this.hostCalls.traceHostCall(result === undefined ? `${pcLog} Result` : `${pcLog} Status(${PvmExecution[result]})`, index, hostCall, regs, gas.get());
+            pvmInstance.registers.setAllEncoded(regs.getEncoded());
+            if (result === PvmExecution.Halt) {
+                status = Status.HALT;
+                return this.getReturnValue(status, pvmInstance);
+            }
+            if (result === PvmExecution.Panic) {
+                status = Status.PANIC;
+                return this.getReturnValue(status, pvmInstance);
+            }
+            if (result === PvmExecution.OOG) {
+                status = Status.OOG;
+                return this.getReturnValue(status, pvmInstance);
+            }
+            if (result === undefined) {
+                pvmInstance.runProgram();
+                status = pvmInstance.getStatus();
+                continue;
+            }
+            assertNever(result);
+        }
+    }
+    async runProgram(program, args, initialPc, initialGas) {
+        const pvmInstance = await this.pvmInstanceManager.getInstance();
+        pvmInstance.resetJam(program, args, initialPc, initialGas);
+        try {
+            return await this.execute(pvmInstance);
+        }
+        finally {
+            this.pvmInstanceManager.releaseInstance(pvmInstance);
+        }
+    }
+}
+
+const logger$3 = Logger.new(import.meta.filename, "host-calls-pvm");
+/** Container for all available host calls. */
+class HostCallsManager {
+    hostCalls = new Map();
+    missing;
+    constructor({ missing, handlers = [], }) {
+        this.missing = missing;
+        for (const handler of handlers) {
+            check `${this.hostCalls.get(handler.index) === undefined} Overwriting host call handler at index ${handler.index}`;
+            this.hostCalls.set(handler.index, handler);
+        }
+    }
+    /** Get a host call by index. */
+    get(hostCallIndex) {
+        return this.hostCalls.get(hostCallIndex) ?? this.missing;
+    }
+    traceHostCall(context, hostCallIndex, hostCallHandler, registers, gas) {
+        const { currentServiceId } = hostCallHandler;
+        const requested = hostCallIndex !== hostCallHandler.index ? ` (${hostCallIndex})` : "";
+        const name = `${hostCallHandler.constructor.name}:${hostCallHandler.index}`;
+        const registerValues = hostCallHandler.tracedRegisters
+            .map((idx) => [idx.toString().padStart(2, "0"), registers.get(idx)])
+            .filter((v) => v[1] !== 0n)
+            .map(([idx, value]) => {
+            return `r${idx}=${value} (0x${value.toString(16)})`;
+        })
+            .join(", ");
+        logger$3.insane `[${currentServiceId}] ${context} ${name}${requested}.  Gas: ${gas}. Regs: ${registerValues}.`;
+    }
+}
+
 /** Create a new gas counter instance depending on the gas value. */
 function gasCounter(gas) {
     return new GasCounterU64(tryAsU64(gas));
 }
 class GasCounterU64 {
     gas;
+    initialGas;
     constructor(gas) {
         this.gas = gas;
+        this.initialGas = tryAsGas(gas);
     }
     set(g) {
         this.gas = tryAsU64(g);
@@ -12965,1593 +13215,1788 @@ class GasCounterU64 {
         this.gas = tryAsU64(0n);
         return true;
     }
+    used() {
+        const gasConsumed = tryAsU64(this.initialGas) - this.gas;
+        // In we have less than zero left we assume that all gas has been consumed.
+        if (gasConsumed < 0) {
+            return this.initialGas;
+        }
+        return tryAsGas(gasConsumed);
+    }
 }
 
+const tryAsMemoryIndex = (index) => {
+    check `${index >= 0 && index <= MAX_MEMORY_INDEX} Incorrect memory index: ${index}!`;
+    return asOpaqueType(index);
+};
+const tryAsSbrkIndex = (index) => {
+    check `${index >= 0 && index <= MAX_MEMORY_INDEX + 1} Incorrect sbrk index: ${index}!`;
+    return asOpaqueType(index);
+};
+
+const PAGE_SIZE_SHIFT = 12;
+// PAGE_SIZE has to be a power of 2
+const PAGE_SIZE$1 = 1 << PAGE_SIZE_SHIFT;
+const MIN_ALLOCATION_SHIFT = (() => {
+    const MIN_ALLOCATION_SHIFT = 7;
+    check `${MIN_ALLOCATION_SHIFT < PAGE_SIZE_SHIFT} incorrect minimal allocation shift`;
+    return MIN_ALLOCATION_SHIFT;
+})();
+const MIN_ALLOCATION_LENGTH = PAGE_SIZE$1 >> MIN_ALLOCATION_SHIFT;
+const LAST_PAGE_NUMBER = (MEMORY_SIZE - PAGE_SIZE$1) / PAGE_SIZE$1;
+/** https://graypaper.fluffylabs.dev/#/68eaa1f/35a60235a602?v=0.6.4 */
+const RESERVED_NUMBER_OF_PAGES = 16;
+/** https://graypaper.fluffylabs.dev/#/68eaa1f/35a60235a602?v=0.6.4 */
+const MAX_NUMBER_OF_PAGES = MEMORY_SIZE / PAGE_SIZE$1;
+
+/** Ensure that given memory `index` is within `[0...PAGE_SIZE)` and can be used to index a page */
+const tryAsPageIndex = (index) => {
+    check `${index >= 0 && index < PAGE_SIZE$1}, Incorect page index: ${index}!`;
+    return asOpaqueType(index);
+};
+/** Ensure that given `index` represents an index of one of the pages. */
+const tryAsPageNumber = (index) => {
+    check `${index >= 0 && index <= LAST_PAGE_NUMBER}, Incorect page number: ${index}!`;
+    return asOpaqueType(index);
+};
 /**
- * Upper bound of instruction distance - it is equal to max value of GP's skip function + 1
- */
-const MAX_INSTRUCTION_DISTANCE = 25;
-/**
- * Mask class is an implementation of skip function defined in GP.
+ * Get the next page number and wrap the result if it is bigger than LAST_PAGE_NUMBER
  *
- * https://graypaper.fluffylabs.dev/#/5f542d7/237201239801
+ * GP references:
+ * 1. The modulo subscription operator is used in all load/store instructions, for example:
+ * https://graypaper.fluffylabs.dev/#/579bd12/25af0125af01
+ *
+ * 2. Here is the definition of the modulo subscription operator:
+ * https://graypaper.fluffylabs.dev/#/579bd12/073a00073a00
  */
-class Mask {
-    /**
-     * The lookup table will have `0` at the index which corresponds to an instruction on the same index in the bytecode.
-     * In case the value is non-zero it signifies the offset to the index with next instruction.
-     *
-     * Example:
-     * ```
-     * 0..1..2..3..4..5..6..7..8..9 # Indices
-     * 0..2..1..0..1..0..3..2..1..0 # lookupTable forward values
-     * ```
-     * There are instructions at indices `0, 3, 5, 9`.
-     */
-    lookupTableForward;
-    constructor(mask) {
-        this.lookupTableForward = this.buildLookupTableForward(mask);
+function getNextPageNumber(pageNumber) {
+    const newPageNumber = pageNumber === LAST_PAGE_NUMBER ? 0 : pageNumber + 1;
+    return tryAsPageNumber(newPageNumber);
+}
+
+function alignToPageSize$1(length) {
+    return PAGE_SIZE$1 * Math.ceil(length / PAGE_SIZE$1);
+}
+function getPageNumber(address) {
+    return tryAsPageNumber(address >>> PAGE_SIZE_SHIFT);
+}
+function getStartPageIndex(address) {
+    return tryAsMemoryIndex((address >>> PAGE_SIZE_SHIFT) << PAGE_SIZE_SHIFT);
+}
+function getStartPageIndexFromPageNumber(pageNumber) {
+    // >>> 0 is needed to avoid changing sign of the number
+    return tryAsMemoryIndex((pageNumber << PAGE_SIZE_SHIFT) >>> 0);
+}
+
+class PageFault {
+    address;
+    isAccessFault;
+    constructor(address, isAccessFault = true) {
+        this.address = address;
+        this.isAccessFault = isAccessFault;
     }
-    isInstruction(index) {
-        return this.lookupTableForward[index] === 0;
+    static fromPageNumber(maybePageNumber, isAccessFault = false) {
+        const pageNumber = tryAsPageNumber(maybePageNumber);
+        const startPageIndex = getStartPageIndexFromPageNumber(pageNumber);
+        return new PageFault(tryAsU32(startPageIndex), isAccessFault);
     }
-    getNoOfBytesToNextInstruction(index) {
-        check `${index >= 0} index (${index}) cannot be a negative number`;
-        return Math.min(this.lookupTableForward[index] ?? 0, MAX_INSTRUCTION_DISTANCE);
+    static fromMemoryIndex(maybeMemoryIndex, isAccessFault = false) {
+        const memoryIndex = tryAsMemoryIndex(maybeMemoryIndex % MEMORY_SIZE);
+        const startPageIndex = getStartPageIndex(memoryIndex);
+        return new PageFault(tryAsU32(startPageIndex), isAccessFault);
     }
-    buildLookupTableForward(mask) {
-        const table = safeAllocUint8Array(mask.bitLength);
-        let lastInstructionOffset = 0;
-        for (let i = mask.bitLength - 1; i >= 0; i--) {
-            if (mask.isSet(i)) {
-                lastInstructionOffset = 0;
-            }
-            else {
-                lastInstructionOffset++;
-            }
-            table[i] = lastInstructionOffset;
-        }
-        return table;
+}
+class IncorrectSbrkIndex extends Error {
+    constructor() {
+        super("Space between sbrk index and max heap index should be empty!");
     }
-    static empty() {
-        return new Mask(BitVec.empty(0));
+}
+class FinalizedBuilderModification extends Error {
+    constructor() {
+        super("MemoryBuilder was finalized and cannot be changed!");
     }
 }
-
-var ArgumentType;
-(function (ArgumentType) {
-    ArgumentType[ArgumentType["NO_ARGUMENTS"] = 0] = "NO_ARGUMENTS";
-    ArgumentType[ArgumentType["ONE_IMMEDIATE"] = 1] = "ONE_IMMEDIATE";
-    ArgumentType[ArgumentType["TWO_IMMEDIATES"] = 2] = "TWO_IMMEDIATES";
-    ArgumentType[ArgumentType["ONE_OFFSET"] = 3] = "ONE_OFFSET";
-    ArgumentType[ArgumentType["ONE_REGISTER_ONE_IMMEDIATE"] = 4] = "ONE_REGISTER_ONE_IMMEDIATE";
-    ArgumentType[ArgumentType["ONE_REGISTER_TWO_IMMEDIATES"] = 5] = "ONE_REGISTER_TWO_IMMEDIATES";
-    ArgumentType[ArgumentType["ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET"] = 6] = "ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET";
-    ArgumentType[ArgumentType["TWO_REGISTERS"] = 7] = "TWO_REGISTERS";
-    ArgumentType[ArgumentType["TWO_REGISTERS_ONE_IMMEDIATE"] = 8] = "TWO_REGISTERS_ONE_IMMEDIATE";
-    ArgumentType[ArgumentType["TWO_REGISTERS_ONE_OFFSET"] = 9] = "TWO_REGISTERS_ONE_OFFSET";
-    ArgumentType[ArgumentType["TWO_REGISTERS_TWO_IMMEDIATES"] = 10] = "TWO_REGISTERS_TWO_IMMEDIATES";
-    ArgumentType[ArgumentType["THREE_REGISTERS"] = 11] = "THREE_REGISTERS";
-    ArgumentType[ArgumentType["ONE_REGISTER_ONE_EXTENDED_WIDTH_IMMEDIATE"] = 12] = "ONE_REGISTER_ONE_EXTENDED_WIDTH_IMMEDIATE";
-})(ArgumentType || (ArgumentType = {}));
-
-const BUFFER_SIZE = 8;
-const IMMEDIATE_SIZE$1 = 4;
-const U32_INDEX = 0;
-const U64_INDEX = 0;
-class ImmediateDecoder {
-    u32;
-    i32;
-    u64;
-    i64;
-    view;
-    bytes;
+class ReservedMemoryFault extends Error {
     constructor() {
-        const buffer = new ArrayBuffer(BUFFER_SIZE);
-        this.u32 = new Uint32Array(buffer);
-        this.i32 = new Int32Array(buffer);
-        this.u64 = new BigUint64Array(buffer);
-        this.i64 = new BigInt64Array(buffer);
-        this.view = new DataView(buffer);
-        this.bytes = new Uint8Array(buffer);
+        super("You are trying to access reserved memory!");
     }
-    setBytes(bytes) {
-        const n = bytes.length;
-        const msb = n > 0 ? bytes[n - 1] & 0x80 : 0;
-        const noOfBytes = Math.min(n, BUFFER_SIZE);
-        const prefix = msb !== 0 ? 0xff : 0x00;
-        for (let i = 0; i < noOfBytes; i++) {
-            this.view.setUint8(i, bytes[i]);
-        }
-        for (let i = n; i < BUFFER_SIZE; i++) {
-            this.view.setUint8(i, prefix);
-        }
+}
+class PageNotExist extends Error {
+    constructor() {
+        super("You try to fill data on memory page that does not exist!");
+    }
+}
+class OutOfMemory extends Error {
+    constructor() {
+        super("Out of memory");
     }
+}
+
+/**
+ * A representation of open-ended range of consecutive indices in memory,
+ * possibly empty or wrapping around.
+ *
+ * `[start, start + length)`
+ */
+class MemoryRange {
+    start;
+    length;
     /**
-     * @deprecated Use getU32 instead
+     * Exclusive end index of the range.
+     *
+     * NOTE: The index may be wrapped around and smaller than `start`!
      */
-    getUnsigned() {
-        return this.u32[U32_INDEX];
-    }
+    end;
     /**
-     * @deprecated Use getI32 instead
+     * Inclusive last index of the range (present unless the range is empty).
+     *
+     * NOTE: the index may be wrapped around and smaller than `start`!
      */
-    getSigned() {
-        return this.i32[U32_INDEX];
-    }
-    getU32() {
-        return this.u32[U32_INDEX];
+    lastIndex = null;
+    constructor(start, length) {
+        this.start = start;
+        this.length = length;
+        this.end = tryAsMemoryIndex((this.start + this.length) % MEMORY_SIZE);
+        if (length > 0) {
+            this.lastIndex = tryAsMemoryIndex((this.end - 1 + MEMORY_SIZE) % MEMORY_SIZE);
+        }
     }
-    getI32() {
-        return this.i32[U32_INDEX];
+    /** Creates a memory range from given starting point and length */
+    static fromStartAndLength(start, length) {
+        if (!Number.isInteger(length) || length < 0 || length > MEMORY_SIZE) {
+            throw new TypeError(`length must be a non-negative integer and less than ${MEMORY_SIZE}, got ${length}`);
+        }
+        return new MemoryRange(start, length);
     }
-    getU64() {
-        return this.u64[U64_INDEX];
+    /** Checks if a range is empty (`length === 0`) */
+    isEmpty() {
+        return this.length === 0;
     }
-    getI64() {
-        return this.i64[U64_INDEX];
+    /** Returns true if the range is wrapped (`start` >= `end`) and is not empty */
+    isWrapped() {
+        return this.start >= this.end && !this.isEmpty();
     }
-    getBytesAsLittleEndian() {
-        return this.bytes.subarray(0, IMMEDIATE_SIZE$1);
+    /** Checks if given memory address is within the range */
+    isInRange(address) {
+        if (this.isWrapped()) {
+            return address >= this.start || address < this.end;
+        }
+        return address >= this.start && address < this.end;
     }
-    getExtendedBytesAsLittleEndian() {
-        return this.bytes;
+    /** Checks if this range overlaps with another range */
+    overlapsWith(other) {
+        if (this.lastIndex === null || other.lastIndex === null) {
+            return false;
+        }
+        return (this.isInRange(other.start) ||
+            this.isInRange(other.lastIndex) ||
+            other.isInRange(this.start) ||
+            other.isInRange(this.lastIndex));
     }
 }
+/**
+ * The first 16 pages of memory are reserved.
+ *
+ * https://graypaper.fluffylabs.dev/#/cc517d7/24d00024d000?v=0.6.5
+ *
+ * it should be in `memory-consts` but it cannot be there because of circular dependency
+ */
+const RESERVED_MEMORY_RANGE = MemoryRange.fromStartAndLength(tryAsMemoryIndex(0), RESERVED_NUMBER_OF_PAGES * PAGE_SIZE$1);
 
-const MAX_REGISTER_INDEX = NO_OF_REGISTERS$1 - 1;
-const MAX_LENGTH = 4;
-class NibblesDecoder {
-    byte = new Int8Array(1);
-    setByte(byte) {
-        this.byte[0] = byte;
-    }
-    getHighNibble() {
-        return (this.byte[0] & 0xf0) >>> 4;
-    }
-    getLowNibble() {
-        return this.byte[0] & 0x0f;
+/**
+ * A half-open range of memory pages. Similarly to [`MemoryRange`], can be empty
+ * or wrapped around the memory.
+ */
+class PageRange {
+    start;
+    length;
+    /**
+     * Exclusive end of the page range.
+     *
+     * NOTE: it may be smaller than `start` in case the range is wrapped.
+     */
+    end;
+    constructor(start, length) {
+        this.start = start;
+        this.length = length;
+        this.end = tryAsPageNumber((this.start + this.length) % MAX_NUMBER_OF_PAGES);
     }
-    getHighNibbleAsRegisterIndex() {
-        return Math.min(this.getHighNibble(), MAX_REGISTER_INDEX);
+    /**
+     * Creates range of pages that includes all indices in a given memory range.
+     *
+     * Example: For memory range `[PAGE_SIZE, MEMORY_SIZE - PAGE_SIZE)`
+     *                  we will get `[1, MAX_NUMBER_OF_PAGES - 1)` page range.
+     */
+    static fromMemoryRange(range) {
+        const startPage = getPageNumber(range.start);
+        if (range.isEmpty()) {
+            return new PageRange(startPage, 0);
+        }
+        // lastIndex is not null because we just ensured that the range is not empty
+        const pageWithLastIndex = getPageNumber(range.lastIndex ?? range.end);
+        const endPage = getNextPageNumber(pageWithLastIndex);
+        if ((startPage === endPage || startPage === pageWithLastIndex) && range.length > PAGE_SIZE$1) {
+            // full range
+            return new PageRange(startPage, MAX_NUMBER_OF_PAGES);
+        }
+        const length = startPage < endPage ? endPage - startPage : MAX_NUMBER_OF_PAGES - startPage + endPage;
+        return PageRange.fromStartAndLength(startPage, length);
     }
-    getLowNibbleAsRegisterIndex() {
-        return Math.min(this.getLowNibble(), MAX_REGISTER_INDEX);
+    /** Creates a page range from given starting point and length */
+    static fromStartAndLength(start, length) {
+        if (!Number.isInteger(length) || length < 0 || length > MAX_NUMBER_OF_PAGES) {
+            throw new TypeError(`length must be a non-negative integer and less than ${MAX_NUMBER_OF_PAGES}, got ${length}`);
+        }
+        return new PageRange(start, length);
     }
-    getHighNibbleAsLength() {
-        return Math.min(this.getHighNibble(), MAX_LENGTH);
+    /** Returns true if the page range is wrapped (`start` >= `end`) and is not empty */
+    isWrapped() {
+        return this.start >= this.end && !this.isEmpty();
     }
-    getLowNibbleAsLength() {
-        return Math.min(this.getLowNibble(), MAX_LENGTH);
+    /** Checks if given page number is within the range */
+    isInRange(page) {
+        if (this.isWrapped()) {
+            return page >= this.start || page < this.end;
+        }
+        return page >= this.start && page < this.end;
     }
-}
-
-const IMMEDIATE_AND_OFFSET_MAX_LENGTH = 4;
-class ArgsDecoder {
-    nibblesDecoder = new NibblesDecoder();
-    offsetDecoder = new ImmediateDecoder();
-    code = new Uint8Array();
-    mask = Mask.empty();
-    reset(code, mask) {
-        this.code = code;
-        this.mask = mask;
+    /** Checks if a range is empty (`length === 0`) */
+    isEmpty() {
+        return this.length === 0;
     }
-    fillArgs(pc, result) {
-        const nextInstructionDistance = 1 + this.mask.getNoOfBytesToNextInstruction(pc + 1);
-        result.noOfBytesToSkip = nextInstructionDistance;
-        switch (result.type) {
-            case ArgumentType.NO_ARGUMENTS:
-                break;
-            case ArgumentType.ONE_IMMEDIATE: {
-                const immediateLength = Math.min(IMMEDIATE_AND_OFFSET_MAX_LENGTH, nextInstructionDistance - 1);
-                const argsStartIndex = pc + 1;
-                result.immediateDecoder.setBytes(this.code.subarray(argsStartIndex, argsStartIndex + immediateLength));
-                break;
-            }
-            case ArgumentType.THREE_REGISTERS: {
-                const firstByte = this.code[pc + 1];
-                const secondByte = this.code[pc + 2];
-                this.nibblesDecoder.setByte(firstByte);
-                result.firstRegisterIndex = this.nibblesDecoder.getLowNibbleAsRegisterIndex();
-                result.secondRegisterIndex = this.nibblesDecoder.getHighNibbleAsRegisterIndex();
-                this.nibblesDecoder.setByte(secondByte);
-                result.thirdRegisterIndex = this.nibblesDecoder.getLowNibbleAsRegisterIndex();
-                break;
-            }
-            case ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE: {
-                const firstByte = this.code[pc + 1];
-                this.nibblesDecoder.setByte(firstByte);
-                result.firstRegisterIndex = this.nibblesDecoder.getLowNibbleAsRegisterIndex();
-                result.secondRegisterIndex = this.nibblesDecoder.getHighNibbleAsRegisterIndex();
-                const immediateLength = Math.min(IMMEDIATE_AND_OFFSET_MAX_LENGTH, Math.max(0, nextInstructionDistance - 2));
-                const immediateStartIndex = pc + 2;
-                const immediateEndIndex = immediateStartIndex + immediateLength;
-                result.immediateDecoder.setBytes(this.code.subarray(immediateStartIndex, immediateEndIndex));
-                break;
-            }
-            case ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET: {
-                const firstByte = this.code[pc + 1];
-                this.nibblesDecoder.setByte(firstByte);
-                result.registerIndex = this.nibblesDecoder.getLowNibbleAsRegisterIndex();
-                const immediateLength = this.nibblesDecoder.getHighNibbleAsLength();
-                const immediateStartIndex = pc + 2;
-                const immediateEndIndex = immediateStartIndex + immediateLength;
-                result.immediateDecoder.setBytes(this.code.subarray(immediateStartIndex, immediateEndIndex));
-                const offsetLength = Math.min(IMMEDIATE_AND_OFFSET_MAX_LENGTH, Math.max(0, nextInstructionDistance - 2 - immediateLength));
-                const offsetStartIndex = pc + 2 + immediateLength;
-                const offsetEndIndex = offsetStartIndex + offsetLength;
-                this.offsetDecoder.setBytes(this.code.subarray(offsetStartIndex, offsetEndIndex));
-                result.nextPc = pc + this.offsetDecoder.getSigned();
-                break;
-            }
-            case ArgumentType.TWO_REGISTERS_ONE_OFFSET: {
-                const firstByte = this.code[pc + 1];
-                this.nibblesDecoder.setByte(firstByte);
-                result.firstRegisterIndex = this.nibblesDecoder.getLowNibbleAsRegisterIndex();
-                result.secondRegisterIndex = this.nibblesDecoder.getHighNibbleAsRegisterIndex();
-                const offsetLength = Math.min(IMMEDIATE_AND_OFFSET_MAX_LENGTH, Math.max(0, nextInstructionDistance - 2));
-                const offsetStartIndex = pc + 2;
-                const offsetEndIndex = offsetStartIndex + offsetLength;
-                this.offsetDecoder.setBytes(this.code.subarray(offsetStartIndex, offsetEndIndex));
-                result.nextPc = pc + this.offsetDecoder.getSigned();
-                break;
-            }
-            case ArgumentType.TWO_REGISTERS: {
-                const firstByte = this.code[pc + 1];
-                this.nibblesDecoder.setByte(firstByte);
-                result.firstRegisterIndex = this.nibblesDecoder.getHighNibbleAsRegisterIndex();
-                result.secondRegisterIndex = this.nibblesDecoder.getLowNibbleAsRegisterIndex();
-                break;
-            }
-            case ArgumentType.ONE_OFFSET: {
-                const offsetLength = Math.min(IMMEDIATE_AND_OFFSET_MAX_LENGTH, nextInstructionDistance - 1);
-                const offsetStartIndex = pc + 1;
-                const offsetEndIndex = offsetStartIndex + offsetLength;
-                const offsetBytes = this.code.subarray(offsetStartIndex, offsetEndIndex);
-                this.offsetDecoder.setBytes(offsetBytes);
-                const offsetValue = this.offsetDecoder.getSigned();
-                result.nextPc = pc + offsetValue;
-                break;
-            }
-            case ArgumentType.ONE_REGISTER_ONE_IMMEDIATE: {
-                const firstByte = this.code[pc + 1];
-                this.nibblesDecoder.setByte(firstByte);
-                result.registerIndex = this.nibblesDecoder.getLowNibbleAsRegisterIndex();
-                const immediateLength = Math.min(IMMEDIATE_AND_OFFSET_MAX_LENGTH, Math.max(0, nextInstructionDistance - 2));
-                const immediateStartIndex = pc + 2;
-                const immediateEndIndex = immediateStartIndex + immediateLength;
-                const immediateBytes = this.code.subarray(immediateStartIndex, immediateEndIndex);
-                result.immediateDecoder.setBytes(immediateBytes);
-                break;
-            }
-            case ArgumentType.TWO_IMMEDIATES: {
-                const firstByte = this.code[pc + 1];
-                this.nibblesDecoder.setByte(firstByte);
-                const firstImmediateLength = this.nibblesDecoder.getLowNibbleAsLength();
-                const firstImmediateStartIndex = pc + 2;
-                const firstImmediateEndIndex = firstImmediateStartIndex + firstImmediateLength;
-                const firstImmediateBytes = this.code.subarray(firstImmediateStartIndex, firstImmediateEndIndex);
-                result.firstImmediateDecoder.setBytes(firstImmediateBytes);
-                const secondImmediateLength = Math.min(IMMEDIATE_AND_OFFSET_MAX_LENGTH, Math.max(0, nextInstructionDistance - 2 - firstImmediateLength));
-                const secondImmediateStartIndex = firstImmediateEndIndex;
-                const secondImmediateEndIndex = secondImmediateStartIndex + secondImmediateLength;
-                const secondImmediateBytes = this.code.subarray(secondImmediateStartIndex, secondImmediateEndIndex);
-                result.secondImmediateDecoder.setBytes(secondImmediateBytes);
-                break;
-            }
-            case ArgumentType.ONE_REGISTER_TWO_IMMEDIATES: {
-                const firstByte = this.code[pc + 1];
-                this.nibblesDecoder.setByte(firstByte);
-                result.registerIndex = this.nibblesDecoder.getLowNibbleAsRegisterIndex();
-                const firstImmediateLength = this.nibblesDecoder.getHighNibbleAsLength();
-                const firstImmediateStartIndex = pc + 2;
-                const firstImmediateEndIndex = firstImmediateStartIndex + firstImmediateLength;
-                const firstImmediateBytes = this.code.subarray(firstImmediateStartIndex, firstImmediateEndIndex);
-                result.firstImmediateDecoder.setBytes(firstImmediateBytes);
-                const secondImmediateLength = Math.min(IMMEDIATE_AND_OFFSET_MAX_LENGTH, Math.max(0, nextInstructionDistance - 2 - firstImmediateLength));
-                const secondImmediateStartIndex = firstImmediateEndIndex;
-                const secondImmediateEndIndex = secondImmediateStartIndex + secondImmediateLength;
-                const secondImmediateBytes = this.code.subarray(secondImmediateStartIndex, secondImmediateEndIndex);
-                result.secondImmediateDecoder.setBytes(secondImmediateBytes);
-                break;
-            }
-            case ArgumentType.TWO_REGISTERS_TWO_IMMEDIATES: {
-                const firstByte = this.code[pc + 1];
-                this.nibblesDecoder.setByte(firstByte);
-                result.firstRegisterIndex = this.nibblesDecoder.getLowNibbleAsRegisterIndex();
-                result.secondRegisterIndex = this.nibblesDecoder.getHighNibbleAsRegisterIndex();
-                const secondByte = this.code[pc + 2];
-                this.nibblesDecoder.setByte(secondByte);
-                const firstImmediateLength = this.nibblesDecoder.getLowNibbleAsLength();
-                const firstImmediateStartIndex = pc + 3;
-                const firstImmediateEndIndex = firstImmediateStartIndex + firstImmediateLength;
-                const firstImmediateBytes = this.code.subarray(firstImmediateStartIndex, firstImmediateEndIndex);
-                result.firstImmediateDecoder.setBytes(firstImmediateBytes);
-                const secondImmediateLength = Math.min(IMMEDIATE_AND_OFFSET_MAX_LENGTH, Math.max(0, nextInstructionDistance - 3 - firstImmediateLength));
-                const secondImmediateStartIndex = firstImmediateEndIndex;
-                const secondImmediateEndIndex = secondImmediateStartIndex + secondImmediateLength;
-                const secondImmediateBytes = this.code.subarray(secondImmediateStartIndex, secondImmediateEndIndex);
-                result.secondImmediateDecoder.setBytes(secondImmediateBytes);
-                break;
-            }
-            case ArgumentType.ONE_REGISTER_ONE_EXTENDED_WIDTH_IMMEDIATE: {
-                const firstByte = this.code[pc + 1];
-                this.nibblesDecoder.setByte(firstByte);
-                result.registerIndex = this.nibblesDecoder.getLowNibbleAsRegisterIndex();
-                const immediateStartIndex = pc + 2;
-                const immediateEndIndex = immediateStartIndex + 8;
-                const immediateBytes = this.code.subarray(immediateStartIndex, immediateEndIndex);
-                result.immediateDecoder.setBytes(immediateBytes);
-                break;
-            }
+    *[Symbol.iterator]() {
+        if (this.isEmpty()) {
+            return;
         }
+        const end = this.end;
+        let i = this.start;
+        do {
+            yield i;
+            i = getNextPageNumber(i);
+        } while (i !== end);
     }
 }
 
-const IMMEDIATE_SIZE = 8;
-class ExtendedWitdthImmediateDecoder {
-    unsignedImmediate;
-    bytes;
-    constructor() {
-        const buffer = new ArrayBuffer(IMMEDIATE_SIZE);
-        this.unsignedImmediate = new BigUint64Array(buffer);
-        this.bytes = new Uint8Array(buffer);
+class MemoryPage {
+    start;
+    constructor(pageNumber) {
+        this.start = getStartPageIndexFromPageNumber(pageNumber);
     }
-    setBytes(bytes) {
-        let i = 0;
-        for (; i < bytes.length; i++) {
-            this.bytes[i] = bytes[i];
-        }
-        for (; i < IMMEDIATE_SIZE; i++) {
-            this.bytes[i] = 0;
+}
+
+class ReadablePage extends MemoryPage {
+    data;
+    constructor(pageNumber, data) {
+        super(pageNumber);
+        this.data = data;
+    }
+    loadInto(result, startIndex, length) {
+        const endIndex = startIndex + length;
+        if (endIndex > PAGE_SIZE$1) {
+            return Result$1.error(PageFault.fromMemoryIndex(this.start + PAGE_SIZE$1), () => `Page fault: read beyond page boundary at ${this.start + PAGE_SIZE$1}`);
         }
+        const bytes = this.data.subarray(startIndex, endIndex);
+        // we zero the bytes, since data might not yet be initialized at `endIndex`.
+        result.fill(0, bytes.length, length);
+        result.set(bytes);
+        return Result$1.ok(OK);
     }
-    getValue() {
-        return this.unsignedImmediate[0];
+    storeFrom(_address, _data) {
+        return Result$1.error(PageFault.fromMemoryIndex(this.start, true), () => `Page fault: attempted to write to read-only page at ${this.start}`);
     }
-    getBytesAsLittleEndian() {
-        return this.bytes.subarray(0, IMMEDIATE_SIZE);
+    setData(pageIndex, data) {
+        this.data.set(data, pageIndex);
+    }
+    isWriteable() {
+        return false;
+    }
+    getPageDump() {
+        return this.data;
     }
 }
 
-const ARGUMENT_TYPE_LENGTH = Object.keys(ArgumentType).length / 2;
-const createResults = () => {
-    const results = new Array(ARGUMENT_TYPE_LENGTH);
-    results[ArgumentType.NO_ARGUMENTS] = {
-        type: ArgumentType.NO_ARGUMENTS,
-        noOfBytesToSkip: 1,
-    };
-    results[ArgumentType.ONE_IMMEDIATE] = {
-        type: ArgumentType.ONE_IMMEDIATE,
-        noOfBytesToSkip: 1,
-        immediateDecoder: new ImmediateDecoder(),
-    };
-    results[ArgumentType.TWO_REGISTERS] = {
-        type: ArgumentType.TWO_REGISTERS,
-        noOfBytesToSkip: 1,
-        firstRegisterIndex: 0,
-        secondRegisterIndex: 0,
-    };
-    results[ArgumentType.THREE_REGISTERS] = {
-        type: ArgumentType.THREE_REGISTERS,
-        noOfBytesToSkip: 1,
-        firstRegisterIndex: 0,
-        secondRegisterIndex: 0,
-        thirdRegisterIndex: 0,
-    };
-    results[ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET] = {
-        type: ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET,
-        noOfBytesToSkip: 1,
-        registerIndex: 0,
-        immediateDecoder: new ImmediateDecoder(),
-        nextPc: 0,
-    };
-    results[ArgumentType.TWO_REGISTERS_ONE_OFFSET] = {
-        type: ArgumentType.TWO_REGISTERS_ONE_OFFSET,
-        noOfBytesToSkip: 1,
-        firstRegisterIndex: 0,
-        secondRegisterIndex: 0,
-        nextPc: 0,
-    };
-    results[ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE] = {
-        type: ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE,
-        noOfBytesToSkip: 1,
-        firstRegisterIndex: 0,
-        secondRegisterIndex: 0,
-        immediateDecoder: new ImmediateDecoder(),
-    };
-    results[ArgumentType.ONE_REGISTER_ONE_IMMEDIATE] = {
-        type: ArgumentType.ONE_REGISTER_ONE_IMMEDIATE,
-        noOfBytesToSkip: 1,
-        registerIndex: 0,
-        immediateDecoder: new ImmediateDecoder(),
-    };
-    results[ArgumentType.ONE_REGISTER_TWO_IMMEDIATES] = {
-        type: ArgumentType.ONE_REGISTER_TWO_IMMEDIATES,
-        noOfBytesToSkip: 1,
-        registerIndex: 0,
-        firstImmediateDecoder: new ImmediateDecoder(),
-        secondImmediateDecoder: new ImmediateDecoder(),
-    };
-    results[ArgumentType.ONE_OFFSET] = {
-        type: ArgumentType.ONE_OFFSET,
-        noOfBytesToSkip: 1,
-        nextPc: 0,
-    };
-    results[ArgumentType.TWO_IMMEDIATES] = {
-        type: ArgumentType.TWO_IMMEDIATES,
-        noOfBytesToSkip: 1,
-        firstImmediateDecoder: new ImmediateDecoder(),
-        secondImmediateDecoder: new ImmediateDecoder(),
-    };
-    results[ArgumentType.TWO_REGISTERS_TWO_IMMEDIATES] = {
-        type: ArgumentType.TWO_REGISTERS_TWO_IMMEDIATES,
-        noOfBytesToSkip: 1,
-        firstImmediateDecoder: new ImmediateDecoder(),
-        secondImmediateDecoder: new ImmediateDecoder(),
-        firstRegisterIndex: 0,
-        secondRegisterIndex: 0,
-    };
-    results[ArgumentType.ONE_REGISTER_ONE_EXTENDED_WIDTH_IMMEDIATE] = {
-        type: ArgumentType.ONE_REGISTER_ONE_EXTENDED_WIDTH_IMMEDIATE,
-        noOfBytesToSkip: 9,
-        registerIndex: 0,
-        immediateDecoder: new ExtendedWitdthImmediateDecoder(),
-    };
-    return results;
-};
+class WriteablePage extends MemoryPage {
+    buffer;
+    view;
+    constructor(pageNumber, initialData) {
+        super(pageNumber);
+        const dataLength = initialData?.length ?? 0;
+        const initialPageLength = Math.min(PAGE_SIZE$1, Math.max(dataLength, MIN_ALLOCATION_LENGTH));
+        this.buffer = new ArrayBuffer(initialPageLength, { maxByteLength: PAGE_SIZE$1 });
+        this.view = new Uint8Array(this.buffer);
+        if (initialData !== undefined) {
+            this.view.set(initialData);
+        }
+    }
+    loadInto(result, startIndex, length) {
+        const endIndex = startIndex + length;
+        if (endIndex > PAGE_SIZE$1) {
+            return Result$1.error(PageFault.fromMemoryIndex(this.start + PAGE_SIZE$1), () => `Page fault: read beyond page boundary at ${this.start + PAGE_SIZE$1}`);
+        }
+        const bytes = this.view.subarray(startIndex, endIndex);
+        // we zero the bytes, since the view might not yet be initialized at `endIndex`.
+        result.fill(0, bytes.length, length);
+        result.set(bytes);
+        return Result$1.ok(OK);
+    }
+    storeFrom(startIndex, bytes) {
+        if (this.buffer.byteLength < startIndex + bytes.length && this.buffer.byteLength < PAGE_SIZE$1) {
+            const newLength = Math.min(PAGE_SIZE$1, Math.max(MIN_ALLOCATION_LENGTH, startIndex + bytes.length));
+            this.buffer.resize(newLength);
+        }
+        this.view.set(bytes, startIndex);
+        return Result$1.ok(OK);
+    }
+    setData(pageIndex, data) {
+        if (this.buffer.byteLength < pageIndex + data.length && this.buffer.byteLength < PAGE_SIZE$1) {
+            const newLength = Math.min(PAGE_SIZE$1, Math.max(MIN_ALLOCATION_LENGTH, pageIndex + data.length));
+            this.buffer.resize(newLength);
+        }
+        this.view.set(data, pageIndex);
+    }
+    isWriteable() {
+        return true;
+    }
+    getPageDump() {
+        return this.view;
+    }
+}
 
-var Instruction;
-(function (Instruction) {
-    Instruction[Instruction["TRAP"] = 0] = "TRAP";
-    Instruction[Instruction["FALLTHROUGH"] = 1] = "FALLTHROUGH";
-    Instruction[Instruction["ECALLI"] = 10] = "ECALLI";
-    Instruction[Instruction["LOAD_IMM_64"] = 20] = "LOAD_IMM_64";
-    Instruction[Instruction["STORE_IMM_U8"] = 30] = "STORE_IMM_U8";
-    Instruction[Instruction["STORE_IMM_U16"] = 31] = "STORE_IMM_U16";
-    Instruction[Instruction["STORE_IMM_U32"] = 32] = "STORE_IMM_U32";
-    Instruction[Instruction["STORE_IMM_U64"] = 33] = "STORE_IMM_U64";
-    Instruction[Instruction["JUMP"] = 40] = "JUMP";
-    Instruction[Instruction["JUMP_IND"] = 50] = "JUMP_IND";
-    Instruction[Instruction["LOAD_IMM"] = 51] = "LOAD_IMM";
-    Instruction[Instruction["LOAD_U8"] = 52] = "LOAD_U8";
-    Instruction[Instruction["LOAD_I8"] = 53] = "LOAD_I8";
-    Instruction[Instruction["LOAD_U16"] = 54] = "LOAD_U16";
-    Instruction[Instruction["LOAD_I16"] = 55] = "LOAD_I16";
-    Instruction[Instruction["LOAD_U32"] = 56] = "LOAD_U32";
-    Instruction[Instruction["LOAD_I32"] = 57] = "LOAD_I32";
-    Instruction[Instruction["LOAD_U64"] = 58] = "LOAD_U64";
-    Instruction[Instruction["STORE_U8"] = 59] = "STORE_U8";
-    Instruction[Instruction["STORE_U16"] = 60] = "STORE_U16";
-    Instruction[Instruction["STORE_U32"] = 61] = "STORE_U32";
-    Instruction[Instruction["STORE_U64"] = 62] = "STORE_U64";
-    Instruction[Instruction["STORE_IMM_IND_U8"] = 70] = "STORE_IMM_IND_U8";
-    Instruction[Instruction["STORE_IMM_IND_U16"] = 71] = "STORE_IMM_IND_U16";
-    Instruction[Instruction["STORE_IMM_IND_U32"] = 72] = "STORE_IMM_IND_U32";
-    Instruction[Instruction["STORE_IMM_IND_U64"] = 73] = "STORE_IMM_IND_U64";
-    Instruction[Instruction["LOAD_IMM_JUMP"] = 80] = "LOAD_IMM_JUMP";
-    Instruction[Instruction["BRANCH_EQ_IMM"] = 81] = "BRANCH_EQ_IMM";
-    Instruction[Instruction["BRANCH_NE_IMM"] = 82] = "BRANCH_NE_IMM";
-    Instruction[Instruction["BRANCH_LT_U_IMM"] = 83] = "BRANCH_LT_U_IMM";
-    Instruction[Instruction["BRANCH_LE_U_IMM"] = 84] = "BRANCH_LE_U_IMM";
-    Instruction[Instruction["BRANCH_GE_U_IMM"] = 85] = "BRANCH_GE_U_IMM";
-    Instruction[Instruction["BRANCH_GT_U_IMM"] = 86] = "BRANCH_GT_U_IMM";
-    Instruction[Instruction["BRANCH_LT_S_IMM"] = 87] = "BRANCH_LT_S_IMM";
-    Instruction[Instruction["BRANCH_LE_S_IMM"] = 88] = "BRANCH_LE_S_IMM";
-    Instruction[Instruction["BRANCH_GE_S_IMM"] = 89] = "BRANCH_GE_S_IMM";
-    Instruction[Instruction["BRANCH_GT_S_IMM"] = 90] = "BRANCH_GT_S_IMM";
-    Instruction[Instruction["MOVE_REG"] = 100] = "MOVE_REG";
-    Instruction[Instruction["SBRK"] = 101] = "SBRK";
-    Instruction[Instruction["COUNT_SET_BITS_64"] = 102] = "COUNT_SET_BITS_64";
-    Instruction[Instruction["COUNT_SET_BITS_32"] = 103] = "COUNT_SET_BITS_32";
-    Instruction[Instruction["LEADING_ZERO_BITS_64"] = 104] = "LEADING_ZERO_BITS_64";
-    Instruction[Instruction["LEADING_ZERO_BITS_32"] = 105] = "LEADING_ZERO_BITS_32";
-    Instruction[Instruction["TRAILING_ZERO_BITS_64"] = 106] = "TRAILING_ZERO_BITS_64";
-    Instruction[Instruction["TRAILING_ZERO_BITS_32"] = 107] = "TRAILING_ZERO_BITS_32";
-    Instruction[Instruction["SIGN_EXTEND_8"] = 108] = "SIGN_EXTEND_8";
-    Instruction[Instruction["SIGN_EXTEND_16"] = 109] = "SIGN_EXTEND_16";
-    Instruction[Instruction["ZERO_EXTEND_16"] = 110] = "ZERO_EXTEND_16";
-    Instruction[Instruction["REVERSE_BYTES"] = 111] = "REVERSE_BYTES";
-    Instruction[Instruction["STORE_IND_U8"] = 120] = "STORE_IND_U8";
-    Instruction[Instruction["STORE_IND_U16"] = 121] = "STORE_IND_U16";
-    Instruction[Instruction["STORE_IND_U32"] = 122] = "STORE_IND_U32";
-    Instruction[Instruction["STORE_IND_U64"] = 123] = "STORE_IND_U64";
-    Instruction[Instruction["LOAD_IND_U8"] = 124] = "LOAD_IND_U8";
-    Instruction[Instruction["LOAD_IND_I8"] = 125] = "LOAD_IND_I8";
-    Instruction[Instruction["LOAD_IND_U16"] = 126] = "LOAD_IND_U16";
-    Instruction[Instruction["LOAD_IND_I16"] = 127] = "LOAD_IND_I16";
-    Instruction[Instruction["LOAD_IND_U32"] = 128] = "LOAD_IND_U32";
-    Instruction[Instruction["LOAD_IND_I32"] = 129] = "LOAD_IND_I32";
-    Instruction[Instruction["LOAD_IND_U64"] = 130] = "LOAD_IND_U64";
-    Instruction[Instruction["ADD_IMM_32"] = 131] = "ADD_IMM_32";
-    Instruction[Instruction["AND_IMM"] = 132] = "AND_IMM";
-    Instruction[Instruction["XOR_IMM"] = 133] = "XOR_IMM";
-    Instruction[Instruction["OR_IMM"] = 134] = "OR_IMM";
-    Instruction[Instruction["MUL_IMM_32"] = 135] = "MUL_IMM_32";
-    Instruction[Instruction["SET_LT_U_IMM"] = 136] = "SET_LT_U_IMM";
-    Instruction[Instruction["SET_LT_S_IMM"] = 137] = "SET_LT_S_IMM";
-    Instruction[Instruction["SHLO_L_IMM_32"] = 138] = "SHLO_L_IMM_32";
-    Instruction[Instruction["SHLO_R_IMM_32"] = 139] = "SHLO_R_IMM_32";
-    Instruction[Instruction["SHAR_R_IMM_32"] = 140] = "SHAR_R_IMM_32";
-    Instruction[Instruction["NEG_ADD_IMM_32"] = 141] = "NEG_ADD_IMM_32";
-    Instruction[Instruction["SET_GT_U_IMM"] = 142] = "SET_GT_U_IMM";
-    Instruction[Instruction["SET_GT_S_IMM"] = 143] = "SET_GT_S_IMM";
-    Instruction[Instruction["SHLO_L_IMM_ALT_32"] = 144] = "SHLO_L_IMM_ALT_32";
-    Instruction[Instruction["SHLO_R_IMM_ALT_32"] = 145] = "SHLO_R_IMM_ALT_32";
-    Instruction[Instruction["SHAR_R_IMM_ALT_32"] = 146] = "SHAR_R_IMM_ALT_32";
-    Instruction[Instruction["CMOV_IZ_IMM"] = 147] = "CMOV_IZ_IMM";
-    Instruction[Instruction["CMOV_NZ_IMM"] = 148] = "CMOV_NZ_IMM";
-    Instruction[Instruction["ADD_IMM_64"] = 149] = "ADD_IMM_64";
-    Instruction[Instruction["MUL_IMM_64"] = 150] = "MUL_IMM_64";
-    Instruction[Instruction["SHLO_L_IMM_64"] = 151] = "SHLO_L_IMM_64";
-    Instruction[Instruction["SHLO_R_IMM_64"] = 152] = "SHLO_R_IMM_64";
-    Instruction[Instruction["SHAR_R_IMM_64"] = 153] = "SHAR_R_IMM_64";
-    Instruction[Instruction["NEG_ADD_IMM_64"] = 154] = "NEG_ADD_IMM_64";
-    Instruction[Instruction["SHLO_L_IMM_ALT_64"] = 155] = "SHLO_L_IMM_ALT_64";
-    Instruction[Instruction["SHLO_R_IMM_ALT_64"] = 156] = "SHLO_R_IMM_ALT_64";
-    Instruction[Instruction["SHAR_R_IMM_ALT_64"] = 157] = "SHAR_R_IMM_ALT_64";
-    Instruction[Instruction["ROT_R_64_IMM"] = 158] = "ROT_R_64_IMM";
-    Instruction[Instruction["ROT_R_64_IMM_ALT"] = 159] = "ROT_R_64_IMM_ALT";
-    Instruction[Instruction["ROT_R_32_IMM"] = 160] = "ROT_R_32_IMM";
-    Instruction[Instruction["ROT_R_32_IMM_ALT"] = 161] = "ROT_R_32_IMM_ALT";
-    Instruction[Instruction["BRANCH_EQ"] = 170] = "BRANCH_EQ";
-    Instruction[Instruction["BRANCH_NE"] = 171] = "BRANCH_NE";
-    Instruction[Instruction["BRANCH_LT_U"] = 172] = "BRANCH_LT_U";
-    Instruction[Instruction["BRANCH_LT_S"] = 173] = "BRANCH_LT_S";
-    Instruction[Instruction["BRANCH_GE_U"] = 174] = "BRANCH_GE_U";
-    Instruction[Instruction["BRANCH_GE_S"] = 175] = "BRANCH_GE_S";
-    Instruction[Instruction["LOAD_IMM_JUMP_IND"] = 180] = "LOAD_IMM_JUMP_IND";
-    Instruction[Instruction["ADD_32"] = 190] = "ADD_32";
-    Instruction[Instruction["SUB_32"] = 191] = "SUB_32";
-    Instruction[Instruction["MUL_32"] = 192] = "MUL_32";
-    Instruction[Instruction["DIV_U_32"] = 193] = "DIV_U_32";
-    Instruction[Instruction["DIV_S_32"] = 194] = "DIV_S_32";
-    Instruction[Instruction["REM_U_32"] = 195] = "REM_U_32";
-    Instruction[Instruction["REM_S_32"] = 196] = "REM_S_32";
-    Instruction[Instruction["SHLO_L_32"] = 197] = "SHLO_L_32";
-    Instruction[Instruction["SHLO_R_32"] = 198] = "SHLO_R_32";
-    Instruction[Instruction["SHAR_R_32"] = 199] = "SHAR_R_32";
-    Instruction[Instruction["ADD_64"] = 200] = "ADD_64";
-    Instruction[Instruction["SUB_64"] = 201] = "SUB_64";
-    Instruction[Instruction["MUL_64"] = 202] = "MUL_64";
-    Instruction[Instruction["DIV_U_64"] = 203] = "DIV_U_64";
-    Instruction[Instruction["DIV_S_64"] = 204] = "DIV_S_64";
-    Instruction[Instruction["REM_U_64"] = 205] = "REM_U_64";
-    Instruction[Instruction["REM_S_64"] = 206] = "REM_S_64";
-    Instruction[Instruction["SHLO_L_64"] = 207] = "SHLO_L_64";
-    Instruction[Instruction["SHLO_R_64"] = 208] = "SHLO_R_64";
-    Instruction[Instruction["SHAR_R_64"] = 209] = "SHAR_R_64";
-    Instruction[Instruction["AND"] = 210] = "AND";
-    Instruction[Instruction["XOR"] = 211] = "XOR";
-    Instruction[Instruction["OR"] = 212] = "OR";
-    Instruction[Instruction["MUL_UPPER_S_S"] = 213] = "MUL_UPPER_S_S";
-    Instruction[Instruction["MUL_UPPER_U_U"] = 214] = "MUL_UPPER_U_U";
-    Instruction[Instruction["MUL_UPPER_S_U"] = 215] = "MUL_UPPER_S_U";
-    Instruction[Instruction["SET_LT_U"] = 216] = "SET_LT_U";
-    Instruction[Instruction["SET_LT_S"] = 217] = "SET_LT_S";
-    Instruction[Instruction["CMOV_IZ"] = 218] = "CMOV_IZ";
-    Instruction[Instruction["CMOV_NZ"] = 219] = "CMOV_NZ";
-    Instruction[Instruction["ROT_L_64"] = 220] = "ROT_L_64";
-    Instruction[Instruction["ROT_L_32"] = 221] = "ROT_L_32";
-    Instruction[Instruction["ROT_R_64"] = 222] = "ROT_R_64";
-    Instruction[Instruction["ROT_R_32"] = 223] = "ROT_R_32";
-    Instruction[Instruction["AND_INV"] = 224] = "AND_INV";
-    Instruction[Instruction["OR_INV"] = 225] = "OR_INV";
-    Instruction[Instruction["XNOR"] = 226] = "XNOR";
-    Instruction[Instruction["MAX"] = 227] = "MAX";
-    Instruction[Instruction["MAX_U"] = 228] = "MAX_U";
-    Instruction[Instruction["MIN"] = 229] = "MIN";
-    Instruction[Instruction["MIN_U"] = 230] = "MIN_U";
-})(Instruction || (Instruction = {}));
-const HIGHEST_INSTRUCTION_NUMBER = Instruction.MIN_U;
-
-const instructionArgumentTypeMap = (() => {
-    const instructionArgumentTypeMap = new Array(HIGHEST_INSTRUCTION_NUMBER + 1);
-    instructionArgumentTypeMap[Instruction.TRAP] = ArgumentType.NO_ARGUMENTS;
-    instructionArgumentTypeMap[Instruction.FALLTHROUGH] = ArgumentType.NO_ARGUMENTS;
-    instructionArgumentTypeMap[Instruction.ECALLI] = ArgumentType.ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.LOAD_IMM_64] = ArgumentType.ONE_REGISTER_ONE_EXTENDED_WIDTH_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.STORE_IMM_U8] = ArgumentType.TWO_IMMEDIATES;
-    instructionArgumentTypeMap[Instruction.STORE_IMM_U16] = ArgumentType.TWO_IMMEDIATES;
-    instructionArgumentTypeMap[Instruction.STORE_IMM_U32] = ArgumentType.TWO_IMMEDIATES;
-    instructionArgumentTypeMap[Instruction.STORE_IMM_U64] = ArgumentType.TWO_IMMEDIATES;
-    instructionArgumentTypeMap[Instruction.JUMP] = ArgumentType.ONE_OFFSET;
-    instructionArgumentTypeMap[Instruction.JUMP_IND] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.LOAD_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.LOAD_U8] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.LOAD_I8] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.LOAD_U16] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.LOAD_I16] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.LOAD_U32] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.LOAD_I32] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.LOAD_U64] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.STORE_U8] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.STORE_U16] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.STORE_U32] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.STORE_U64] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.STORE_IMM_IND_U8] = ArgumentType.ONE_REGISTER_TWO_IMMEDIATES;
-    instructionArgumentTypeMap[Instruction.STORE_IMM_IND_U16] = ArgumentType.ONE_REGISTER_TWO_IMMEDIATES;
-    instructionArgumentTypeMap[Instruction.STORE_IMM_IND_U32] = ArgumentType.ONE_REGISTER_TWO_IMMEDIATES;
-    instructionArgumentTypeMap[Instruction.STORE_IMM_IND_U64] = ArgumentType.ONE_REGISTER_TWO_IMMEDIATES;
-    instructionArgumentTypeMap[Instruction.LOAD_IMM_JUMP] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
-    instructionArgumentTypeMap[Instruction.BRANCH_EQ_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
-    instructionArgumentTypeMap[Instruction.BRANCH_NE_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
-    instructionArgumentTypeMap[Instruction.BRANCH_LT_U_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
-    instructionArgumentTypeMap[Instruction.BRANCH_LE_U_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
-    instructionArgumentTypeMap[Instruction.BRANCH_GE_U_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
-    instructionArgumentTypeMap[Instruction.BRANCH_GT_U_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
-    instructionArgumentTypeMap[Instruction.BRANCH_LT_S_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
-    instructionArgumentTypeMap[Instruction.BRANCH_LE_S_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
-    instructionArgumentTypeMap[Instruction.BRANCH_GE_S_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
-    instructionArgumentTypeMap[Instruction.BRANCH_GT_S_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
-    instructionArgumentTypeMap[Instruction.MOVE_REG] = ArgumentType.TWO_REGISTERS;
-    instructionArgumentTypeMap[Instruction.SBRK] = ArgumentType.TWO_REGISTERS;
-    instructionArgumentTypeMap[Instruction.COUNT_SET_BITS_64] = ArgumentType.TWO_REGISTERS;
-    instructionArgumentTypeMap[Instruction.COUNT_SET_BITS_32] = ArgumentType.TWO_REGISTERS;
-    instructionArgumentTypeMap[Instruction.LEADING_ZERO_BITS_64] = ArgumentType.TWO_REGISTERS;
-    instructionArgumentTypeMap[Instruction.LEADING_ZERO_BITS_32] = ArgumentType.TWO_REGISTERS;
-    instructionArgumentTypeMap[Instruction.TRAILING_ZERO_BITS_64] = ArgumentType.TWO_REGISTERS;
-    instructionArgumentTypeMap[Instruction.TRAILING_ZERO_BITS_32] = ArgumentType.TWO_REGISTERS;
-    instructionArgumentTypeMap[Instruction.SIGN_EXTEND_8] = ArgumentType.TWO_REGISTERS;
-    instructionArgumentTypeMap[Instruction.SIGN_EXTEND_16] = ArgumentType.TWO_REGISTERS;
-    instructionArgumentTypeMap[Instruction.ZERO_EXTEND_16] = ArgumentType.TWO_REGISTERS;
-    instructionArgumentTypeMap[Instruction.REVERSE_BYTES] = ArgumentType.TWO_REGISTERS;
-    instructionArgumentTypeMap[Instruction.STORE_IND_U8] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.STORE_IND_U16] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.STORE_IND_U32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.STORE_IND_U64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.LOAD_IND_U8] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.LOAD_IND_I8] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.LOAD_IND_U16] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.LOAD_IND_I16] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.LOAD_IND_U32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.LOAD_IND_I32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.LOAD_IND_U64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.ADD_IMM_32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.ADD_IMM_64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.AND_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.XOR_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.OR_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.MUL_IMM_32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.MUL_IMM_64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.SET_LT_U_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.SET_LT_S_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.SHLO_L_IMM_32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.SHLO_R_IMM_32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.SHAR_R_IMM_32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.NEG_ADD_IMM_32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.SHLO_L_IMM_64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.SHLO_R_IMM_64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.SHAR_R_IMM_64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.NEG_ADD_IMM_64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.SET_GT_U_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.SET_GT_S_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.SHLO_L_IMM_ALT_32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.SHLO_R_IMM_ALT_32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.SHAR_R_IMM_ALT_32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.SHLO_L_IMM_ALT_64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.SHLO_R_IMM_ALT_64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.SHAR_R_IMM_ALT_64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.CMOV_IZ_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.CMOV_NZ_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.ROT_R_64_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.ROT_R_64_IMM_ALT] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.ROT_R_32_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.ROT_R_32_IMM_ALT] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[Instruction.BRANCH_EQ] = ArgumentType.TWO_REGISTERS_ONE_OFFSET;
-    instructionArgumentTypeMap[Instruction.BRANCH_NE] = ArgumentType.TWO_REGISTERS_ONE_OFFSET;
-    instructionArgumentTypeMap[Instruction.BRANCH_LT_U] = ArgumentType.TWO_REGISTERS_ONE_OFFSET;
-    instructionArgumentTypeMap[Instruction.BRANCH_LT_S] = ArgumentType.TWO_REGISTERS_ONE_OFFSET;
-    instructionArgumentTypeMap[Instruction.BRANCH_GE_U] = ArgumentType.TWO_REGISTERS_ONE_OFFSET;
-    instructionArgumentTypeMap[Instruction.BRANCH_GE_S] = ArgumentType.TWO_REGISTERS_ONE_OFFSET;
-    instructionArgumentTypeMap[Instruction.LOAD_IMM_JUMP_IND] = ArgumentType.TWO_REGISTERS_TWO_IMMEDIATES;
-    instructionArgumentTypeMap[Instruction.ADD_32] = ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[Instruction.ADD_64] = ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[Instruction.SUB_32] = ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[Instruction.SUB_64] = ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[Instruction.AND] = ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[Instruction.XOR] = ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[Instruction.OR] = ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[Instruction.MUL_32] = ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[Instruction.MUL_64] = ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[Instruction.MUL_UPPER_S_S] = ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[Instruction.MUL_UPPER_U_U] = ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[Instruction.MUL_UPPER_S_U] = ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[Instruction.DIV_U_32] = ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[Instruction.DIV_S_32] = ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[Instruction.REM_U_32] = ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[Instruction.REM_S_32] = ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[Instruction.DIV_U_64] = ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[Instruction.DIV_S_64] = ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[Instruction.REM_U_64] = ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[Instruction.REM_S_64] = ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[Instruction.SET_LT_U] = ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[Instruction.SET_LT_S] = ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[Instruction.SHLO_L_32] = ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[Instruction.SHLO_R_32] = ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[Instruction.SHAR_R_32] = ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[Instruction.SHLO_L_64] = ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[Instruction.SHLO_R_64] = ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[Instruction.SHAR_R_64] = ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[Instruction.CMOV_IZ] = ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[Instruction.CMOV_NZ] = ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[Instruction.ROT_L_64] = ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[Instruction.ROT_L_32] = ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[Instruction.ROT_R_64] = ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[Instruction.ROT_R_32] = ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[Instruction.AND_INV] = ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[Instruction.OR_INV] = ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[Instruction.XNOR] = ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[Instruction.MAX] = ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[Instruction.MAX_U] = ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[Instruction.MIN] = ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[Instruction.MIN_U] = ArgumentType.THREE_REGISTERS;
-    return instructionArgumentTypeMap;
-})();
-
-const instructionsWithoutArgs = [
-    [Instruction.TRAP, 1],
-    [Instruction.FALLTHROUGH, 1],
-];
-const instructionsWithOneImmediate = [[Instruction.ECALLI, 1]];
-const instructionsWithOneRegisterAndOneExtendedWidthImmediate = [[Instruction.LOAD_IMM_64, 1]];
-const instructionsWithTwoImmediates = [
-    [Instruction.STORE_IMM_U8, 1],
-    [Instruction.STORE_IMM_U16, 1],
-    [Instruction.STORE_IMM_U32, 1],
-    [Instruction.STORE_IMM_U64, 1],
-];
-const instructionsWithOneOffset = [[Instruction.JUMP, 1]];
-const instructionsWithOneRegisterAndOneImmediate = [
-    [Instruction.JUMP_IND, 1],
-    [Instruction.LOAD_IMM, 1],
-    [Instruction.LOAD_U8, 1],
-    [Instruction.LOAD_I8, 1],
-    [Instruction.LOAD_U16, 1],
-    [Instruction.LOAD_I16, 1],
-    [Instruction.LOAD_U32, 1],
-    [Instruction.LOAD_I32, 1],
-    [Instruction.LOAD_U64, 1],
-    [Instruction.STORE_U8, 1],
-    [Instruction.STORE_U16, 1],
-    [Instruction.STORE_U32, 1],
-    [Instruction.STORE_U64, 1],
-];
-const instructionsWithOneRegisterAndTwoImmediate = [
-    [Instruction.STORE_IMM_IND_U8, 1],
-    [Instruction.STORE_IMM_IND_U16, 1],
-    [Instruction.STORE_IMM_IND_U32, 1],
-    [Instruction.STORE_IMM_IND_U64, 1],
-];
-const instructionsWithOneRegisterOneImmediateAndOneOffset = [
-    [Instruction.LOAD_IMM_JUMP, 1],
-    [Instruction.BRANCH_EQ_IMM, 1],
-    [Instruction.BRANCH_NE_IMM, 1],
-    [Instruction.BRANCH_LT_U_IMM, 1],
-    [Instruction.BRANCH_LE_U_IMM, 1],
-    [Instruction.BRANCH_GE_U_IMM, 1],
-    [Instruction.BRANCH_GT_U_IMM, 1],
-    [Instruction.BRANCH_LT_S_IMM, 1],
-    [Instruction.BRANCH_LE_S_IMM, 1],
-    [Instruction.BRANCH_GE_S_IMM, 1],
-    [Instruction.BRANCH_GT_S_IMM, 1],
-];
-const instructionsWithTwoRegisters = [
-    [Instruction.MOVE_REG, 1],
-    [Instruction.SBRK, 1],
-    [Instruction.COUNT_SET_BITS_64, 1],
-    [Instruction.COUNT_SET_BITS_32, 1],
-    [Instruction.LEADING_ZERO_BITS_64, 1],
-    [Instruction.LEADING_ZERO_BITS_32, 1],
-    [Instruction.TRAILING_ZERO_BITS_64, 1],
-    [Instruction.TRAILING_ZERO_BITS_32, 1],
-    [Instruction.SIGN_EXTEND_8, 1],
-    [Instruction.SIGN_EXTEND_16, 1],
-    [Instruction.ZERO_EXTEND_16, 1],
-    [Instruction.REVERSE_BYTES, 1],
-];
-const instructionsWithTwoRegistersAndOneImmediate = [
-    [Instruction.STORE_IND_U8, 1],
-    [Instruction.STORE_IND_U16, 1],
-    [Instruction.STORE_IND_U32, 1],
-    [Instruction.STORE_IND_U64, 1],
-    [Instruction.LOAD_IND_U8, 1],
-    [Instruction.LOAD_IND_I8, 1],
-    [Instruction.LOAD_IND_U16, 1],
-    [Instruction.LOAD_IND_I16, 1],
-    [Instruction.LOAD_IND_U32, 1],
-    [Instruction.LOAD_IND_I32, 1],
-    [Instruction.LOAD_IND_U64, 1],
-    [Instruction.ADD_IMM_32, 1],
-    [Instruction.AND_IMM, 1],
-    [Instruction.XOR_IMM, 1],
-    [Instruction.OR_IMM, 1],
-    [Instruction.MUL_IMM_32, 1],
-    [Instruction.SET_LT_U_IMM, 1],
-    [Instruction.SET_LT_S_IMM, 1],
-    [Instruction.SHLO_L_IMM_32, 1],
-    [Instruction.SHLO_R_IMM_32, 1],
-    [Instruction.SHAR_R_IMM_32, 1],
-    [Instruction.NEG_ADD_IMM_32, 1],
-    [Instruction.SET_GT_U_IMM, 1],
-    [Instruction.SET_GT_S_IMM, 1],
-    [Instruction.SHLO_L_IMM_ALT_32, 1],
-    [Instruction.SHLO_R_IMM_ALT_32, 1],
-    [Instruction.SHAR_R_IMM_ALT_32, 1],
-    [Instruction.CMOV_IZ_IMM, 1],
-    [Instruction.CMOV_NZ_IMM, 1],
-    [Instruction.ADD_IMM_64, 1],
-    [Instruction.MUL_IMM_64, 1],
-    [Instruction.SHLO_L_IMM_64, 1],
-    [Instruction.SHLO_R_IMM_64, 1],
-    [Instruction.SHAR_R_IMM_64, 1],
-    [Instruction.NEG_ADD_IMM_64, 1],
-    [Instruction.SHLO_L_IMM_ALT_64, 1],
-    [Instruction.SHLO_R_IMM_ALT_64, 1],
-    [Instruction.SHAR_R_IMM_ALT_64, 1],
-    [Instruction.ROT_R_64_IMM, 1],
-    [Instruction.ROT_R_64_IMM_ALT, 1],
-    [Instruction.ROT_R_32_IMM, 1],
-    [Instruction.ROT_R_32_IMM_ALT, 1],
-];
-const instructionsWithTwoRegistersAndOneOffset = [
-    [Instruction.BRANCH_EQ, 1],
-    [Instruction.BRANCH_NE, 1],
-    [Instruction.BRANCH_LT_U, 1],
-    [Instruction.BRANCH_LT_S, 1],
-    [Instruction.BRANCH_GE_U, 1],
-    [Instruction.BRANCH_GE_S, 1],
-];
-const instructionWithTwoRegistersAndTwoImmediates = [[Instruction.LOAD_IMM_JUMP_IND, 1]];
-const instructionsWithThreeRegisters = [
-    [Instruction.ADD_32, 1],
-    [Instruction.SUB_32, 1],
-    [Instruction.MUL_32, 1],
-    [Instruction.DIV_U_32, 1],
-    [Instruction.DIV_S_32, 1],
-    [Instruction.REM_U_32, 1],
-    [Instruction.REM_S_32, 1],
-    [Instruction.SHLO_L_32, 1],
-    [Instruction.SHLO_R_32, 1],
-    [Instruction.SHAR_R_32, 1],
-    [Instruction.ADD_64, 1],
-    [Instruction.SUB_64, 1],
-    [Instruction.MUL_64, 1],
-    [Instruction.DIV_U_64, 1],
-    [Instruction.DIV_S_64, 1],
-    [Instruction.REM_U_64, 1],
-    [Instruction.REM_S_64, 1],
-    [Instruction.SHLO_L_64, 1],
-    [Instruction.SHLO_R_64, 1],
-    [Instruction.SHAR_R_64, 1],
-    [Instruction.AND, 1],
-    [Instruction.XOR, 1],
-    [Instruction.OR, 1],
-    [Instruction.MUL_UPPER_S_S, 1],
-    [Instruction.MUL_UPPER_U_U, 1],
-    [Instruction.MUL_UPPER_S_U, 1],
-    [Instruction.SET_LT_U, 1],
-    [Instruction.SET_LT_S, 1],
-    [Instruction.CMOV_IZ, 1],
-    [Instruction.CMOV_NZ, 1],
-    [Instruction.ROT_L_64, 1],
-    [Instruction.ROT_L_32, 1],
-    [Instruction.ROT_R_64, 1],
-    [Instruction.ROT_R_32, 1],
-    [Instruction.AND_INV, 1],
-    [Instruction.OR_INV, 1],
-    [Instruction.XNOR, 1],
-    [Instruction.MAX, 1],
-    [Instruction.MAX_U, 1],
-    [Instruction.MIN, 1],
-    [Instruction.MIN_U, 1],
-];
-const instructions = [
-    ...instructionsWithoutArgs,
-    ...instructionsWithOneImmediate,
-    ...instructionsWithOneRegisterAndOneExtendedWidthImmediate,
-    ...instructionsWithTwoImmediates,
-    ...instructionsWithOneOffset,
-    ...instructionsWithOneRegisterAndOneImmediate,
-    ...instructionsWithOneRegisterAndTwoImmediate,
-    ...instructionsWithOneRegisterOneImmediateAndOneOffset,
-    ...instructionsWithTwoRegisters,
-    ...instructionsWithTwoRegistersAndOneImmediate,
-    ...instructionsWithTwoRegistersAndOneOffset,
-    ...instructionWithTwoRegistersAndTwoImmediates,
-    ...instructionsWithThreeRegisters,
-];
-const createOpCodeEntry = ([byte, gas]) => [byte, { gas: tryAsSmallGas(gas) }];
-const byteToOpCodeMap = instructions.reduce((acc, instruction) => {
-    const [byte, opCode] = createOpCodeEntry(instruction);
-    acc[byte] = opCode;
-    return acc;
-}, {});
-function assemblify(program, mask) {
-    return program.reduce((acc, byte, index) => {
-        if (mask.isInstruction(index)) {
-            acc.push([Instruction[byte]]);
+var AccessType;
+(function (AccessType) {
+    AccessType[AccessType["READ"] = 0] = "READ";
+    AccessType[AccessType["WRITE"] = 1] = "WRITE";
+})(AccessType || (AccessType = {}));
+const logger$2 = Logger.new(import.meta.filename, "pvm:mem");
+class Memory {
+    sbrkIndex;
+    virtualSbrkIndex;
+    endHeapIndex;
+    memory;
+    static fromInitialMemory(initialMemoryState) {
+        return new Memory(initialMemoryState?.sbrkIndex, initialMemoryState?.sbrkIndex, initialMemoryState?.endHeapIndex, initialMemoryState?.memory);
+    }
+    constructor(sbrkIndex = tryAsSbrkIndex(RESERVED_MEMORY_RANGE.end), virtualSbrkIndex = tryAsSbrkIndex(RESERVED_MEMORY_RANGE.end), endHeapIndex = tryAsSbrkIndex(MAX_MEMORY_INDEX), memory = new Map()) {
+        this.sbrkIndex = sbrkIndex;
+        this.virtualSbrkIndex = virtualSbrkIndex;
+        this.endHeapIndex = endHeapIndex;
+        this.memory = memory;
+    }
+    store(address, bytes) {
+        return this.storeFrom(tryAsMemoryIndex(address), bytes);
+    }
+    read(address, output) {
+        return this.loadInto(output, tryAsMemoryIndex(address));
+    }
+    reset() {
+        this.sbrkIndex = tryAsSbrkIndex(RESERVED_MEMORY_RANGE.end);
+        this.virtualSbrkIndex = tryAsSbrkIndex(RESERVED_MEMORY_RANGE.end);
+        this.endHeapIndex = tryAsSbrkIndex(MAX_MEMORY_INDEX);
+        this.memory = new Map(); // TODO [MaSi]: We should keep allocated pages somewhere and reuse it when it is possible
+    }
+    copyFrom(memory) {
+        this.sbrkIndex = memory.sbrkIndex;
+        this.virtualSbrkIndex = memory.virtualSbrkIndex;
+        this.endHeapIndex = memory.endHeapIndex;
+        this.memory = memory.memory;
+    }
+    storeFrom(address, bytes) {
+        if (bytes.length === 0) {
+            return Result$1.ok(OK);
+        }
+        logger$2.insane `MEM[${address}] <- ${BytesBlob.blobFrom(bytes)}`;
+        const pagesResult = this.getPages(address, bytes.length, AccessType.WRITE);
+        if (pagesResult.isError) {
+            return Result$1.error(pagesResult.error, pagesResult.details);
+        }
+        const pages = pagesResult.ok;
+        let currentPosition = address;
+        let bytesLeft = bytes.length;
+        for (const page of pages) {
+            const pageStartIndex = tryAsPageIndex(currentPosition % PAGE_SIZE$1);
+            const bytesToWrite = Math.min(PAGE_SIZE$1 - pageStartIndex, bytesLeft);
+            const sourceStartIndex = currentPosition - address;
+            const source = bytes.subarray(sourceStartIndex, sourceStartIndex + bytesToWrite);
+            page.storeFrom(pageStartIndex, source);
+            currentPosition += bytesToWrite;
+            bytesLeft -= bytesToWrite;
+        }
+        return Result$1.ok(OK);
+    }
+    getPages(startAddress, length, accessType) {
+        if (length === 0) {
+            return Result$1.ok([]);
+        }
+        const memoryRange = MemoryRange.fromStartAndLength(startAddress, length);
+        const pageRange = PageRange.fromMemoryRange(memoryRange);
+        const pages = [];
+        for (const pageNumber of pageRange) {
+            if (pageNumber < RESERVED_NUMBER_OF_PAGES) {
+                return Result$1.error(PageFault.fromPageNumber(pageNumber, true), () => `Page fault: attempted to access reserved page ${pageNumber}`);
+            }
+            const page = this.memory.get(pageNumber);
+            if (page === undefined) {
+                return Result$1.error(PageFault.fromPageNumber(pageNumber), () => `Page fault: page ${pageNumber} not allocated`);
+            }
+            if (accessType === AccessType.WRITE && !page.isWriteable()) {
+                return Result$1.error(PageFault.fromPageNumber(pageNumber, true), () => `Page fault: attempted to write to read-only page ${pageNumber}`);
+            }
+            pages.push(page);
+        }
+        return Result$1.ok(pages);
+    }
+    /**
+     * Read content of the memory at `[address, address + result.length)` and
+     * write the result into the `result` buffer.
+     *
+     * Returns `null` if the data was read successfully or `PageFault` otherwise.
+     */
+    loadInto(result, startAddress) {
+        if (result.length === 0) {
+            return Result$1.ok(OK);
+        }
+        const pagesResult = this.getPages(startAddress, result.length, AccessType.READ);
+        if (pagesResult.isError) {
+            return Result$1.error(pagesResult.error, pagesResult.details);
+        }
+        const pages = pagesResult.ok;
+        let currentPosition = startAddress;
+        let bytesLeft = result.length;
+        for (const page of pages) {
+            const pageStartIndex = tryAsPageIndex(currentPosition % PAGE_SIZE$1);
+            const bytesToRead = Math.min(PAGE_SIZE$1 - pageStartIndex, bytesLeft);
+            const destinationStartIndex = currentPosition - startAddress;
+            const destination = result.subarray(destinationStartIndex);
+            page.loadInto(destination, pageStartIndex, bytesToRead);
+            currentPosition += bytesToRead;
+            bytesLeft -= bytesToRead;
         }
-        else {
-            acc[acc.length - 1].push(byte);
+        logger$2.insane `MEM[${startAddress}] => ${BytesBlob.blobFrom(result)}`;
+        return Result$1.ok(OK);
+    }
+    sbrk(length) {
+        const currentSbrkIndex = this.sbrkIndex;
+        const currentVirtualSbrkIndex = this.virtualSbrkIndex;
+        // new sbrk index is bigger than 2 ** 32 or endHeapIndex
+        if (MAX_MEMORY_INDEX < currentVirtualSbrkIndex + length || currentVirtualSbrkIndex + length > this.endHeapIndex) {
+            throw new OutOfMemory();
         }
-        return acc;
-    }, []);
+        const newVirtualSbrkIndex = tryAsSbrkIndex(this.virtualSbrkIndex + length);
+        // no alllocation needed
+        if (newVirtualSbrkIndex <= currentSbrkIndex) {
+            this.virtualSbrkIndex = newVirtualSbrkIndex;
+            return currentVirtualSbrkIndex;
+        }
+        // standard allocation using "Writeable" pages
+        const newSbrkIndex = tryAsSbrkIndex(alignToPageSize$1(newVirtualSbrkIndex));
+        // TODO [MaSi]: `getPageNumber` works incorrectly for SbrkIndex. Sbrk index should be changed to MemoryIndex
+        const firstPageNumber = getPageNumber(currentSbrkIndex);
+        const pagesToAllocate = (newSbrkIndex - currentSbrkIndex) / PAGE_SIZE$1;
+        const rangeToAllocate = PageRange.fromStartAndLength(firstPageNumber, pagesToAllocate);
+        for (const pageNumber of rangeToAllocate) {
+            const page = new WriteablePage(pageNumber);
+            this.memory.set(pageNumber, page);
+        }
+        this.virtualSbrkIndex = newVirtualSbrkIndex;
+        this.sbrkIndex = newSbrkIndex;
+        return currentVirtualSbrkIndex;
+    }
+    getPageDump(pageNumber) {
+        const page = this.memory.get(pageNumber);
+        return page?.getPageDump() ?? null;
+    }
+    getDirtyPages() {
+        return this.memory.keys();
+    }
+}
+
+class MemoryBuilder {
+    initialMemory = new Map();
+    isFinalized = false;
+    ensureNotFinalized() {
+        if (this.isFinalized) {
+            throw new FinalizedBuilderModification();
+        }
+    }
+    ensureNoReservedMemoryUsage(range) {
+        if (range.overlapsWith(RESERVED_MEMORY_RANGE)) {
+            throw new ReservedMemoryFault();
+        }
+    }
+    /**
+     * Create entire readable pages to handle the `[start, end)` range.
+     *
+     * Note that both `start` and `end` must be multiple of the `PAGE_SIZE`, i.e.
+     * they need to be the start indices of the pages.
+     *
+     * The data passed will be placed at `start`, but might be shorter than the requested range,
+     * prepend it with zeros if you don't wish to have it at the beginning of the page.
+     */
+    setReadablePages(start, end, data = new Uint8Array()) {
+        this.ensureNotFinalized();
+        check `${start < end} end has to be bigger than start`;
+        check `${start % PAGE_SIZE$1 === 0} start needs to be a multiple of page size (${PAGE_SIZE$1})`;
+        check `${end % PAGE_SIZE$1 === 0} end needs to be a multiple of page size (${PAGE_SIZE$1})`;
+        check `${data.length <= end - start} the initial data is longer than address range`;
+        const length = end - start;
+        const range = MemoryRange.fromStartAndLength(start, length);
+        this.ensureNoReservedMemoryUsage(range);
+        const pages = Array.from(PageRange.fromMemoryRange(range));
+        const noOfPages = pages.length;
+        for (let i = 0; i < noOfPages; i++) {
+            const pageNumber = pages[i];
+            const dataChunk = data.subarray(i * PAGE_SIZE$1, (i + 1) * PAGE_SIZE$1);
+            const page = new ReadablePage(pageNumber, dataChunk);
+            this.initialMemory.set(pageNumber, page);
+        }
+        return this;
+    }
+    /**
+     * Create entire writeable pages to handle the `[start, end)` range.
+     *
+     * Note that both `start` and `end` must be multiple of the `PAGE_SIZE`, i.e.
+     * they need to be the start indices of the pages.
+     *
+     * The data passed will be placed at `start`, but might be shorter than the requested range,
+     * prepend it with zeros if you don't wish to have it at the beginning of the page.
+     */
+    setWriteablePages(start, end, data = new Uint8Array()) {
+        this.ensureNotFinalized();
+        check `${start < end} end has to be bigger than start`;
+        check `${start % PAGE_SIZE$1 === 0} start needs to be a multiple of page size (${PAGE_SIZE$1})`;
+        check `${end % PAGE_SIZE$1 === 0} end needs to be a multiple of page size (${PAGE_SIZE$1})`;
+        check `${data.length <= end - start} the initial data is longer than address range`;
+        const length = end - start;
+        const range = MemoryRange.fromStartAndLength(start, length);
+        this.ensureNoReservedMemoryUsage(range);
+        const pages = Array.from(PageRange.fromMemoryRange(range));
+        const noOfPages = pages.length;
+        for (let i = 0; i < noOfPages; i++) {
+            const pageNumber = pages[i];
+            const dataChunk = data.subarray(i * PAGE_SIZE$1, (i + 1) * PAGE_SIZE$1);
+            const page = new WriteablePage(pageNumber, dataChunk);
+            this.initialMemory.set(pageNumber, page);
+        }
+        return this;
+    }
+    /**
+     * This function can be useful when page map and initial memory data are provided separatelly.
+     * You can use setWriteablePages/setReadablePages to create empty pages and then setData to fill them
+     */
+    setData(start, data) {
+        this.ensureNotFinalized();
+        const pageOffset = start % PAGE_SIZE$1;
+        const remainingSpaceOnPage = PAGE_SIZE$1 - pageOffset;
+        check `${data.length <= remainingSpaceOnPage} The data has to fit into a single page.`;
+        const length = data.length;
+        const range = MemoryRange.fromStartAndLength(start, length);
+        this.ensureNoReservedMemoryUsage(range);
+        const pageNumber = getPageNumber(start);
+        const page = this.initialMemory.get(pageNumber);
+        if (page === undefined) {
+            throw new PageNotExist();
+        }
+        const startPageIndex = tryAsPageIndex(start - page.start);
+        page.setData(startPageIndex, data);
+        return this;
+    }
+    finalize(startHeapIndex, endHeapIndex) {
+        check `
+      ${startHeapIndex <= endHeapIndex}
+      startHeapIndex (${startHeapIndex}) has to be less than or equal to endHeapIndex (${endHeapIndex})
+    `;
+        this.ensureNotFinalized();
+        const heapRange = MemoryRange.fromStartAndLength(startHeapIndex, endHeapIndex - startHeapIndex);
+        const heapPagesRange = PageRange.fromMemoryRange(heapRange);
+        const initializedPageNumbers = Array.from(this.initialMemory.keys());
+        for (const pageNumber of initializedPageNumbers) {
+            if (heapPagesRange.isInRange(pageNumber)) {
+                throw new IncorrectSbrkIndex();
+            }
+        }
+        const memory = Memory.fromInitialMemory({
+            memory: this.initialMemory,
+            sbrkIndex: tryAsSbrkIndex(startHeapIndex),
+            endHeapIndex,
+        });
+        this.isFinalized = true;
+        return memory;
+    }
+}
+
+// GP reference: https://graypaper.fluffylabs.dev/#/7e6ff6a/2d32002d3200?v=0.6.7
+const PAGE_SIZE = 2 ** 12; // Z_P from GP
+const SEGMENT_SIZE = 2 ** 16; // Z_Z from GP
+const DATA_LEGNTH = 2 ** 24; // Z_I from GP
+const STACK_SEGMENT = 0xfe_fe_00_00; // 2^32 - 2Z_Z - Z_I from GP
+const ARGS_SEGMENT = 0xfe_ff_00_00; // 2^32 - Z_Z - Z_I from GP
+const LAST_PAGE = 0xff_ff_00_00;
+
+// GP reference: https://graypaper.fluffylabs.dev/#/579bd12/2bd2022bd202
+function alignToSegmentSize(size) {
+    // Q(x) from GP
+    return SEGMENT_SIZE * Math.ceil(size / SEGMENT_SIZE);
+}
+function alignToPageSize(size) {
+    // P(x) from GP
+    return PAGE_SIZE * Math.ceil(size / PAGE_SIZE);
+}
+
+const NO_OF_REGISTERS = 13;
+class MemorySegment extends WithDebug {
+    start;
+    end;
+    data;
+    static from({ start, end, data }) {
+        return new MemorySegment(start, end, data);
+    }
+    constructor(start, end, data) {
+        super();
+        this.start = start;
+        this.end = end;
+        this.data = data;
+    }
+}
+class SpiMemory extends WithDebug {
+    readable;
+    writeable;
+    sbrkIndex;
+    heapEnd;
+    constructor(readable, writeable, sbrkIndex, heapEnd) {
+        super();
+        this.readable = readable;
+        this.writeable = writeable;
+        this.sbrkIndex = sbrkIndex;
+        this.heapEnd = heapEnd;
+    }
+}
+class SpiProgram extends WithDebug {
+    code;
+    memory;
+    registers;
+    constructor(code, memory, registers) {
+        super();
+        this.code = code;
+        this.memory = memory;
+        this.registers = registers;
+    }
+}
+/**
+ * program = E_3(|o|) ++ E_3(|w|) ++ E_2(z) ++ E_3(s) ++ o ++ w ++ E_4(|c|) ++ c
+ *
+ * E_n - little endian encoding, n - length
+ * o - initial read only data
+ * w - initial heap
+ * z - heap pages filled with zeros
+ * s - stack size
+ * c - program code
+ *
+ * https://graypaper.fluffylabs.dev/#/579bd12/2b92022b9202
+ */
+function decodeStandardProgram(program, args) {
+    const decoder = Decoder.fromBlob(program);
+    const oLength = decoder.u24();
+    const wLength = decoder.u24();
+    check `${args.length <= DATA_LEGNTH} Incorrect arguments length`;
+    check `${oLength <= DATA_LEGNTH} Incorrect readonly segment length`;
+    const readOnlyLength = oLength;
+    check `${wLength <= DATA_LEGNTH} Incorrect heap segment length`;
+    const heapLength = wLength;
+    const noOfHeapZerosPages = decoder.u16();
+    const stackSize = decoder.u24();
+    const readOnlyMemory = decoder.bytes(readOnlyLength).raw;
+    const initialHeap = decoder.bytes(heapLength).raw;
+    const codeLength = decoder.u32();
+    const code = decoder.bytes(codeLength).raw;
+    decoder.finish();
+    const readonlyDataStart = SEGMENT_SIZE;
+    const readonlyDataEnd = SEGMENT_SIZE + alignToPageSize(readOnlyLength);
+    const heapDataStart = 2 * SEGMENT_SIZE + alignToSegmentSize(readOnlyLength);
+    const heapDataEnd = heapDataStart + alignToPageSize(heapLength);
+    const heapZerosEnd = heapDataStart + alignToPageSize(heapLength) + noOfHeapZerosPages * PAGE_SIZE;
+    const stackStart = STACK_SEGMENT - alignToPageSize(stackSize);
+    const stackEnd = STACK_SEGMENT;
+    const argsStart = ARGS_SEGMENT;
+    const argsEnd = argsStart + alignToPageSize(args.length);
+    const argsZerosEnd = argsEnd + alignToPageSize(args.length);
+    function nonEmpty(s) {
+        return s !== false;
+    }
+    const readableMemory = [
+        readOnlyLength > 0 && getMemorySegment(readonlyDataStart, readonlyDataEnd, readOnlyMemory),
+        args.length > 0 && getMemorySegment(argsStart, argsEnd, args),
+        argsEnd < argsZerosEnd && getMemorySegment(argsEnd, argsZerosEnd),
+    ].filter(nonEmpty);
+    const writeableMemory = [
+        heapLength > 0 && getMemorySegment(heapDataStart, heapDataEnd, initialHeap),
+        heapDataEnd < heapZerosEnd && getMemorySegment(heapDataEnd, heapZerosEnd),
+        stackStart < stackEnd && getMemorySegment(stackStart, stackEnd),
+    ].filter(nonEmpty);
+    return new SpiProgram(code, new SpiMemory(readableMemory, writeableMemory, heapZerosEnd, stackStart), getRegisters(args.length));
+}
+function getMemorySegment(start, end, data = null) {
+    return new MemorySegment(start, end, data);
+}
+function getRegisters(argsLength) {
+    const regs = new BigUint64Array(NO_OF_REGISTERS);
+    // GP reference: https://graypaper.fluffylabs.dev/#/579bd12/2c7c012cb101
+    regs[0] = BigInt(LAST_PAGE);
+    regs[1] = BigInt(STACK_SEGMENT);
+    regs[7] = BigInt(ARGS_SEGMENT);
+    regs[8] = BigInt(argsLength);
+    return regs;
 }
 
-const terminationInstructions = (() => {
-    const terminationInstructions = new Array(HIGHEST_INSTRUCTION_NUMBER + 1);
-    terminationInstructions.fill(false);
-    terminationInstructions[Instruction.TRAP] = true;
-    terminationInstructions[Instruction.FALLTHROUGH] = true;
-    terminationInstructions[Instruction.JUMP] = true;
-    terminationInstructions[Instruction.JUMP_IND] = true;
-    terminationInstructions[Instruction.LOAD_IMM_JUMP] = true;
-    terminationInstructions[Instruction.LOAD_IMM_JUMP_IND] = true;
-    terminationInstructions[Instruction.BRANCH_EQ] = true;
-    terminationInstructions[Instruction.BRANCH_NE] = true;
-    terminationInstructions[Instruction.BRANCH_GE_U] = true;
-    terminationInstructions[Instruction.BRANCH_GE_S] = true;
-    terminationInstructions[Instruction.BRANCH_LT_U] = true;
-    terminationInstructions[Instruction.BRANCH_LT_S] = true;
-    terminationInstructions[Instruction.BRANCH_EQ_IMM] = true;
-    terminationInstructions[Instruction.BRANCH_NE_IMM] = true;
-    terminationInstructions[Instruction.BRANCH_LT_U_IMM] = true;
-    terminationInstructions[Instruction.BRANCH_LT_S_IMM] = true;
-    terminationInstructions[Instruction.BRANCH_LE_U_IMM] = true;
-    terminationInstructions[Instruction.BRANCH_LE_S_IMM] = true;
-    terminationInstructions[Instruction.BRANCH_GE_U_IMM] = true;
-    terminationInstructions[Instruction.BRANCH_GE_S_IMM] = true;
-    terminationInstructions[Instruction.BRANCH_GT_U_IMM] = true;
-    terminationInstructions[Instruction.BRANCH_GT_S_IMM] = true;
-    return terminationInstructions;
-})();
+var index$7 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  MemorySegment: MemorySegment,
+  SpiMemory: SpiMemory,
+  SpiProgram: SpiProgram,
+  decodeStandardProgram: decodeStandardProgram
+});
 
-class BasicBlocks {
-    basicBlocks = new Set();
-    reset(code, mask) {
-        this.basicBlocks.clear();
-        this.basicBlocks.add(0);
-        const codeLength = code.length;
-        const isBasicBlockTermination = (index) => mask.isInstruction(index) && terminationInstructions[code[index]];
-        for (let i = 0; i < codeLength; i++) {
-            if (mask.isInstruction(i) && isBasicBlockTermination(i)) {
-                this.basicBlocks.add(i + 1 + mask.getNoOfBytesToNextInstruction(i + 1));
-            }
+class Program {
+    code;
+    registers;
+    memory;
+    metadata;
+    static fromSpi(blob, args, hasMetadata) {
+        const { code: spiCode, metadata } = hasMetadata ? extractCodeAndMetadata(blob) : { code: blob };
+        const { code, memory: rawMemory, registers } = decodeStandardProgram(spiCode, args);
+        const regs = new Registers();
+        regs.copyFrom(registers);
+        const memoryBuilder = new MemoryBuilder();
+        for (const { start, end, data } of rawMemory.readable) {
+            const startIndex = tryAsMemoryIndex(start);
+            const endIndex = tryAsMemoryIndex(end);
+            memoryBuilder.setReadablePages(startIndex, endIndex, data ?? new Uint8Array());
         }
+        for (const { start, end, data } of rawMemory.writeable) {
+            const startIndex = tryAsMemoryIndex(start);
+            const endIndex = tryAsMemoryIndex(end);
+            memoryBuilder.setWriteablePages(startIndex, endIndex, data ?? new Uint8Array());
+        }
+        const heapStart = tryAsMemoryIndex(rawMemory.sbrkIndex);
+        const heapEnd = tryAsSbrkIndex(rawMemory.heapEnd);
+        const memory = memoryBuilder.finalize(heapStart, heapEnd);
+        return new Program(code, regs, memory, metadata);
     }
-    isBeginningOfBasicBlock(index) {
-        return this.basicBlocks.has(index);
-    }
-}
-
-const instructionGasMap = (() => {
-    const instructionGasMap = new Array(HIGHEST_INSTRUCTION_NUMBER + 1);
-    for (let i = 0; i < HIGHEST_INSTRUCTION_NUMBER + 1; i++) {
-        const gas = byteToOpCodeMap[i]?.gas;
-        instructionGasMap[i] = gas;
+    static fromGeneric(blob, hasMetadata) {
+        const { code, metadata } = hasMetadata ? extractCodeAndMetadata(blob) : { code: blob };
+        const regs = new Registers();
+        const memory = new Memory();
+        return new Program(code, regs, memory, metadata);
     }
-    return instructionGasMap;
-})();
-
-class InstructionResult {
-    nextPc = 0;
-    status = null;
-    /**
-     * A numeric exit parameter of the PVM.
-     *
-     * In case of a `status === Result.FAULT` this will be the memory address
-     * that triggered the fault.
-     * In case of a `status === Result.HOST` this will be the host call index
-     * that should be invoked.
-     *
-     * In any other circumstance the value should be `null`.
-     */
-    exitParam = null;
-    reset() {
-        this.nextPc = 0;
-        this.status = null;
-        this.exitParam = null;
+    constructor(code, registers, memory, metadata = new Uint8Array()) {
+        this.code = code;
+        this.registers = registers;
+        this.memory = memory;
+        this.metadata = metadata;
     }
 }
-
-const MAX_MEMORY_INDEX = 0xffff_ffff;
-const MEMORY_SIZE = MAX_MEMORY_INDEX + 1;
-const PAGE_SIZE_SHIFT = 12;
-// PAGE_SIZE has to be a power of 2
-const PAGE_SIZE$1 = 1 << PAGE_SIZE_SHIFT;
-const MIN_ALLOCATION_SHIFT = (() => {
-    const MIN_ALLOCATION_SHIFT = 7;
-    check `${MIN_ALLOCATION_SHIFT < PAGE_SIZE_SHIFT} incorrect minimal allocation shift`;
-    return MIN_ALLOCATION_SHIFT;
-})();
-const MIN_ALLOCATION_LENGTH = PAGE_SIZE$1 >> MIN_ALLOCATION_SHIFT;
-const LAST_PAGE_NUMBER = (MEMORY_SIZE - PAGE_SIZE$1) / PAGE_SIZE$1;
-/** https://graypaper.fluffylabs.dev/#/68eaa1f/35a60235a602?v=0.6.4 */
-const RESERVED_NUMBER_OF_PAGES = 16;
-/** https://graypaper.fluffylabs.dev/#/68eaa1f/35a60235a602?v=0.6.4 */
-const MAX_NUMBER_OF_PAGES = MEMORY_SIZE / PAGE_SIZE$1;
-
-const tryAsMemoryIndex = (index) => {
-    check `${index >= 0 && index <= MAX_MEMORY_INDEX} Incorrect memory index: ${index}!`;
-    return asOpaqueType(index);
-};
-const tryAsSbrkIndex = (index) => {
-    check `${index >= 0 && index <= MAX_MEMORY_INDEX + 1} Incorrect sbrk index: ${index}!`;
-    return asOpaqueType(index);
-};
-
-/** Ensure that given memory `index` is within `[0...PAGE_SIZE)` and can be used to index a page */
-const tryAsPageIndex = (index) => {
-    check `${index >= 0 && index < PAGE_SIZE$1}, Incorect page index: ${index}!`;
-    return asOpaqueType(index);
-};
-/** Ensure that given `index` represents an index of one of the pages. */
-const tryAsPageNumber = (index) => {
-    check `${index >= 0 && index <= LAST_PAGE_NUMBER}, Incorect page number: ${index}!`;
-    return asOpaqueType(index);
-};
 /**
- * Get the next page number and wrap the result if it is bigger than LAST_PAGE_NUMBER
- *
- * GP references:
- * 1. The modulo subscription operator is used in all load/store instructions, for example:
- * https://graypaper.fluffylabs.dev/#/579bd12/25af0125af01
+ * A function that splits preimage into metadata and code.
  *
- * 2. Here is the definition of the modulo subscription operator:
- * https://graypaper.fluffylabs.dev/#/579bd12/073a00073a00
+ * https://graypaper.fluffylabs.dev/#/cc517d7/109a01109a01?v=0.6.5
  */
-function getNextPageNumber(pageNumber) {
-    const newPageNumber = pageNumber === LAST_PAGE_NUMBER ? 0 : pageNumber + 1;
-    return tryAsPageNumber(newPageNumber);
+function extractCodeAndMetadata(blobWithMetadata) {
+    const decoder = Decoder.fromBlob(blobWithMetadata);
+    const metadata = decoder.bytesBlob().raw;
+    const code = decoder.remainingBytes().raw;
+    return { metadata, code };
 }
 
-function alignToPageSize$1(length) {
-    return PAGE_SIZE$1 * Math.ceil(length / PAGE_SIZE$1);
-}
-function getPageNumber(address) {
-    return tryAsPageNumber(address >>> PAGE_SIZE_SHIFT);
-}
-function getStartPageIndex(address) {
-    return tryAsMemoryIndex((address >>> PAGE_SIZE_SHIFT) << PAGE_SIZE_SHIFT);
-}
-function getStartPageIndexFromPageNumber(pageNumber) {
-    // >>> 0 is needed to avoid changing sign of the number
-    return tryAsMemoryIndex((pageNumber << PAGE_SIZE_SHIFT) >>> 0);
-}
+var index$6 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  Program: Program,
+  extractCodeAndMetadata: extractCodeAndMetadata
+});
 
-class PageFault {
-    address;
-    isAccessFault;
-    constructor(address, isAccessFault = true) {
-        this.address = address;
-        this.isAccessFault = isAccessFault;
+/**
+ * Upper bound of instruction distance - it is equal to max value of GP's skip function + 1
+ */
+const MAX_INSTRUCTION_DISTANCE = 25;
+/**
+ * Mask class is an implementation of skip function defined in GP.
+ *
+ * https://graypaper.fluffylabs.dev/#/5f542d7/237201239801
+ */
+class Mask {
+    /**
+     * The lookup table will have `0` at the index which corresponds to an instruction on the same index in the bytecode.
+     * In case the value is non-zero it signifies the offset to the index with next instruction.
+     *
+     * Example:
+     * ```
+     * 0..1..2..3..4..5..6..7..8..9 # Indices
+     * 0..2..1..0..1..0..3..2..1..0 # lookupTable forward values
+     * ```
+     * There are instructions at indices `0, 3, 5, 9`.
+     */
+    lookupTableForward;
+    constructor(mask) {
+        this.lookupTableForward = this.buildLookupTableForward(mask);
     }
-    static fromPageNumber(maybePageNumber, isAccessFault = false) {
-        const pageNumber = tryAsPageNumber(maybePageNumber);
-        const startPageIndex = getStartPageIndexFromPageNumber(pageNumber);
-        return new PageFault(startPageIndex, isAccessFault);
+    isInstruction(index) {
+        return this.lookupTableForward[index] === 0;
+    }
+    getNoOfBytesToNextInstruction(index) {
+        check `${index >= 0} index (${index}) cannot be a negative number`;
+        return Math.min(this.lookupTableForward[index] ?? 0, MAX_INSTRUCTION_DISTANCE);
+    }
+    buildLookupTableForward(mask) {
+        const table = safeAllocUint8Array(mask.bitLength);
+        let lastInstructionOffset = 0;
+        for (let i = mask.bitLength - 1; i >= 0; i--) {
+            if (mask.isSet(i)) {
+                lastInstructionOffset = 0;
+            }
+            else {
+                lastInstructionOffset++;
+            }
+            table[i] = lastInstructionOffset;
+        }
+        return table;
     }
-    static fromMemoryIndex(maybeMemoryIndex, isAccessFault = false) {
-        const memoryIndex = tryAsMemoryIndex(maybeMemoryIndex % MEMORY_SIZE);
-        const startPageIndex = getStartPageIndex(memoryIndex);
-        return new PageFault(startPageIndex, isAccessFault);
+    static empty() {
+        return new Mask(BitVec.empty(0));
     }
 }
-class OutOfBounds extends Error {
+
+var ArgumentType;
+(function (ArgumentType) {
+    ArgumentType[ArgumentType["NO_ARGUMENTS"] = 0] = "NO_ARGUMENTS";
+    ArgumentType[ArgumentType["ONE_IMMEDIATE"] = 1] = "ONE_IMMEDIATE";
+    ArgumentType[ArgumentType["TWO_IMMEDIATES"] = 2] = "TWO_IMMEDIATES";
+    ArgumentType[ArgumentType["ONE_OFFSET"] = 3] = "ONE_OFFSET";
+    ArgumentType[ArgumentType["ONE_REGISTER_ONE_IMMEDIATE"] = 4] = "ONE_REGISTER_ONE_IMMEDIATE";
+    ArgumentType[ArgumentType["ONE_REGISTER_TWO_IMMEDIATES"] = 5] = "ONE_REGISTER_TWO_IMMEDIATES";
+    ArgumentType[ArgumentType["ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET"] = 6] = "ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET";
+    ArgumentType[ArgumentType["TWO_REGISTERS"] = 7] = "TWO_REGISTERS";
+    ArgumentType[ArgumentType["TWO_REGISTERS_ONE_IMMEDIATE"] = 8] = "TWO_REGISTERS_ONE_IMMEDIATE";
+    ArgumentType[ArgumentType["TWO_REGISTERS_ONE_OFFSET"] = 9] = "TWO_REGISTERS_ONE_OFFSET";
+    ArgumentType[ArgumentType["TWO_REGISTERS_TWO_IMMEDIATES"] = 10] = "TWO_REGISTERS_TWO_IMMEDIATES";
+    ArgumentType[ArgumentType["THREE_REGISTERS"] = 11] = "THREE_REGISTERS";
+    ArgumentType[ArgumentType["ONE_REGISTER_ONE_EXTENDED_WIDTH_IMMEDIATE"] = 12] = "ONE_REGISTER_ONE_EXTENDED_WIDTH_IMMEDIATE";
+})(ArgumentType || (ArgumentType = {}));
+
+const BUFFER_SIZE = 8;
+const IMMEDIATE_SIZE$1 = 4;
+const U32_INDEX = 0;
+const U64_INDEX = 0;
+class ImmediateDecoder {
+    u32;
+    i32;
+    u64;
+    i64;
+    view;
+    bytes;
     constructor() {
-        super("Out of bounds");
+        const buffer = new ArrayBuffer(BUFFER_SIZE);
+        this.u32 = new Uint32Array(buffer);
+        this.i32 = new Int32Array(buffer);
+        this.u64 = new BigUint64Array(buffer);
+        this.i64 = new BigInt64Array(buffer);
+        this.view = new DataView(buffer);
+        this.bytes = new Uint8Array(buffer);
     }
-}
-class IncorrectSbrkIndex extends Error {
-    constructor() {
-        super("Space between sbrk index and max heap index should be empty!");
+    setBytes(bytes) {
+        const n = bytes.length;
+        const msb = n > 0 ? bytes[n - 1] & 0x80 : 0;
+        const noOfBytes = Math.min(n, BUFFER_SIZE);
+        const prefix = msb !== 0 ? 0xff : 0x00;
+        for (let i = 0; i < noOfBytes; i++) {
+            this.view.setUint8(i, bytes[i]);
+        }
+        for (let i = n; i < BUFFER_SIZE; i++) {
+            this.view.setUint8(i, prefix);
+        }
     }
-}
-class FinalizedBuilderModification extends Error {
-    constructor() {
-        super("MemoryBuilder was finalized and cannot be changed!");
+    /**
+     * @deprecated Use getU32 instead
+     */
+    getUnsigned() {
+        return this.u32[U32_INDEX];
     }
-}
-class ReservedMemoryFault extends Error {
-    constructor() {
-        super("You are trying to access reserved memory!");
+    /**
+     * @deprecated Use getI32 instead
+     */
+    getSigned() {
+        return this.i32[U32_INDEX];
     }
-}
-class PageNotExist extends Error {
-    constructor() {
-        super("You try to fill data on memory page that does not exist!");
+    getU32() {
+        return this.u32[U32_INDEX];
     }
-}
-class OutOfMemory extends Error {
-    constructor() {
-        super("Out of memory");
+    getI32() {
+        return this.i32[U32_INDEX];
+    }
+    getU64() {
+        return this.u64[U64_INDEX];
+    }
+    getI64() {
+        return this.i64[U64_INDEX];
+    }
+    getBytesAsLittleEndian() {
+        return this.bytes.subarray(0, IMMEDIATE_SIZE$1);
+    }
+    getExtendedBytesAsLittleEndian() {
+        return this.bytes;
     }
 }
 
-/**
- * A representation of open-ended range of consecutive indices in memory,
- * possibly empty or wrapping around.
- *
- * `[start, start + length)`
- */
-class MemoryRange {
-    start;
-    length;
-    /**
-     * Exclusive end index of the range.
-     *
-     * NOTE: The index may be wrapped around and smaller than `start`!
-     */
-    end;
-    /**
-     * Inclusive last index of the range (present unless the range is empty).
-     *
-     * NOTE: the index may be wrapped around and smaller than `start`!
-     */
-    lastIndex = null;
-    constructor(start, length) {
-        this.start = start;
-        this.length = length;
-        this.end = tryAsMemoryIndex((this.start + this.length) % MEMORY_SIZE);
-        if (length > 0) {
-            this.lastIndex = tryAsMemoryIndex((this.end - 1 + MEMORY_SIZE) % MEMORY_SIZE);
-        }
+const MAX_REGISTER_INDEX = NO_OF_REGISTERS$1 - 1;
+const MAX_LENGTH = 4;
+class NibblesDecoder {
+    byte = new Int8Array(1);
+    setByte(byte) {
+        this.byte[0] = byte;
     }
-    /** Creates a memory range from given starting point and length */
-    static fromStartAndLength(start, length) {
-        if (!Number.isInteger(length) || length < 0 || length > MEMORY_SIZE) {
-            throw new TypeError(`length must be a non-negative integer and less than ${MEMORY_SIZE}, got ${length}`);
-        }
-        return new MemoryRange(start, length);
+    getHighNibble() {
+        return (this.byte[0] & 0xf0) >>> 4;
     }
-    /** Checks if a range is empty (`length === 0`) */
-    isEmpty() {
-        return this.length === 0;
+    getLowNibble() {
+        return this.byte[0] & 0x0f;
     }
-    /** Returns true if the range is wrapped (`start` >= `end`) and is not empty */
-    isWrapped() {
-        return this.start >= this.end && !this.isEmpty();
+    getHighNibbleAsRegisterIndex() {
+        return Math.min(this.getHighNibble(), MAX_REGISTER_INDEX);
     }
-    /** Checks if given memory address is within the range */
-    isInRange(address) {
-        if (this.isWrapped()) {
-            return address >= this.start || address < this.end;
-        }
-        return address >= this.start && address < this.end;
+    getLowNibbleAsRegisterIndex() {
+        return Math.min(this.getLowNibble(), MAX_REGISTER_INDEX);
     }
-    /** Checks if this range overlaps with another range */
-    overlapsWith(other) {
-        if (this.lastIndex === null || other.lastIndex === null) {
-            return false;
+    getHighNibbleAsLength() {
+        return Math.min(this.getHighNibble(), MAX_LENGTH);
+    }
+    getLowNibbleAsLength() {
+        return Math.min(this.getLowNibble(), MAX_LENGTH);
+    }
+}
+
+const IMMEDIATE_AND_OFFSET_MAX_LENGTH = 4;
+class ArgsDecoder {
+    nibblesDecoder = new NibblesDecoder();
+    offsetDecoder = new ImmediateDecoder();
+    code = new Uint8Array();
+    mask = Mask.empty();
+    reset(code, mask) {
+        this.code = code;
+        this.mask = mask;
+    }
+    fillArgs(pc, result) {
+        const nextInstructionDistance = 1 + this.mask.getNoOfBytesToNextInstruction(pc + 1);
+        result.noOfBytesToSkip = nextInstructionDistance;
+        switch (result.type) {
+            case ArgumentType.NO_ARGUMENTS:
+                break;
+            case ArgumentType.ONE_IMMEDIATE: {
+                const immediateLength = Math.min(IMMEDIATE_AND_OFFSET_MAX_LENGTH, nextInstructionDistance - 1);
+                const argsStartIndex = pc + 1;
+                result.immediateDecoder.setBytes(this.code.subarray(argsStartIndex, argsStartIndex + immediateLength));
+                break;
+            }
+            case ArgumentType.THREE_REGISTERS: {
+                const firstByte = this.code[pc + 1];
+                const secondByte = this.code[pc + 2];
+                this.nibblesDecoder.setByte(firstByte);
+                result.firstRegisterIndex = this.nibblesDecoder.getLowNibbleAsRegisterIndex();
+                result.secondRegisterIndex = this.nibblesDecoder.getHighNibbleAsRegisterIndex();
+                this.nibblesDecoder.setByte(secondByte);
+                result.thirdRegisterIndex = this.nibblesDecoder.getLowNibbleAsRegisterIndex();
+                break;
+            }
+            case ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE: {
+                const firstByte = this.code[pc + 1];
+                this.nibblesDecoder.setByte(firstByte);
+                result.firstRegisterIndex = this.nibblesDecoder.getLowNibbleAsRegisterIndex();
+                result.secondRegisterIndex = this.nibblesDecoder.getHighNibbleAsRegisterIndex();
+                const immediateLength = Math.min(IMMEDIATE_AND_OFFSET_MAX_LENGTH, Math.max(0, nextInstructionDistance - 2));
+                const immediateStartIndex = pc + 2;
+                const immediateEndIndex = immediateStartIndex + immediateLength;
+                result.immediateDecoder.setBytes(this.code.subarray(immediateStartIndex, immediateEndIndex));
+                break;
+            }
+            case ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET: {
+                const firstByte = this.code[pc + 1];
+                this.nibblesDecoder.setByte(firstByte);
+                result.registerIndex = this.nibblesDecoder.getLowNibbleAsRegisterIndex();
+                const immediateLength = this.nibblesDecoder.getHighNibbleAsLength();
+                const immediateStartIndex = pc + 2;
+                const immediateEndIndex = immediateStartIndex + immediateLength;
+                result.immediateDecoder.setBytes(this.code.subarray(immediateStartIndex, immediateEndIndex));
+                const offsetLength = Math.min(IMMEDIATE_AND_OFFSET_MAX_LENGTH, Math.max(0, nextInstructionDistance - 2 - immediateLength));
+                const offsetStartIndex = pc + 2 + immediateLength;
+                const offsetEndIndex = offsetStartIndex + offsetLength;
+                this.offsetDecoder.setBytes(this.code.subarray(offsetStartIndex, offsetEndIndex));
+                result.nextPc = pc + this.offsetDecoder.getSigned();
+                break;
+            }
+            case ArgumentType.TWO_REGISTERS_ONE_OFFSET: {
+                const firstByte = this.code[pc + 1];
+                this.nibblesDecoder.setByte(firstByte);
+                result.firstRegisterIndex = this.nibblesDecoder.getLowNibbleAsRegisterIndex();
+                result.secondRegisterIndex = this.nibblesDecoder.getHighNibbleAsRegisterIndex();
+                const offsetLength = Math.min(IMMEDIATE_AND_OFFSET_MAX_LENGTH, Math.max(0, nextInstructionDistance - 2));
+                const offsetStartIndex = pc + 2;
+                const offsetEndIndex = offsetStartIndex + offsetLength;
+                this.offsetDecoder.setBytes(this.code.subarray(offsetStartIndex, offsetEndIndex));
+                result.nextPc = pc + this.offsetDecoder.getSigned();
+                break;
+            }
+            case ArgumentType.TWO_REGISTERS: {
+                const firstByte = this.code[pc + 1];
+                this.nibblesDecoder.setByte(firstByte);
+                result.firstRegisterIndex = this.nibblesDecoder.getHighNibbleAsRegisterIndex();
+                result.secondRegisterIndex = this.nibblesDecoder.getLowNibbleAsRegisterIndex();
+                break;
+            }
+            case ArgumentType.ONE_OFFSET: {
+                const offsetLength = Math.min(IMMEDIATE_AND_OFFSET_MAX_LENGTH, nextInstructionDistance - 1);
+                const offsetStartIndex = pc + 1;
+                const offsetEndIndex = offsetStartIndex + offsetLength;
+                const offsetBytes = this.code.subarray(offsetStartIndex, offsetEndIndex);
+                this.offsetDecoder.setBytes(offsetBytes);
+                const offsetValue = this.offsetDecoder.getSigned();
+                result.nextPc = pc + offsetValue;
+                break;
+            }
+            case ArgumentType.ONE_REGISTER_ONE_IMMEDIATE: {
+                const firstByte = this.code[pc + 1];
+                this.nibblesDecoder.setByte(firstByte);
+                result.registerIndex = this.nibblesDecoder.getLowNibbleAsRegisterIndex();
+                const immediateLength = Math.min(IMMEDIATE_AND_OFFSET_MAX_LENGTH, Math.max(0, nextInstructionDistance - 2));
+                const immediateStartIndex = pc + 2;
+                const immediateEndIndex = immediateStartIndex + immediateLength;
+                const immediateBytes = this.code.subarray(immediateStartIndex, immediateEndIndex);
+                result.immediateDecoder.setBytes(immediateBytes);
+                break;
+            }
+            case ArgumentType.TWO_IMMEDIATES: {
+                const firstByte = this.code[pc + 1];
+                this.nibblesDecoder.setByte(firstByte);
+                const firstImmediateLength = this.nibblesDecoder.getLowNibbleAsLength();
+                const firstImmediateStartIndex = pc + 2;
+                const firstImmediateEndIndex = firstImmediateStartIndex + firstImmediateLength;
+                const firstImmediateBytes = this.code.subarray(firstImmediateStartIndex, firstImmediateEndIndex);
+                result.firstImmediateDecoder.setBytes(firstImmediateBytes);
+                const secondImmediateLength = Math.min(IMMEDIATE_AND_OFFSET_MAX_LENGTH, Math.max(0, nextInstructionDistance - 2 - firstImmediateLength));
+                const secondImmediateStartIndex = firstImmediateEndIndex;
+                const secondImmediateEndIndex = secondImmediateStartIndex + secondImmediateLength;
+                const secondImmediateBytes = this.code.subarray(secondImmediateStartIndex, secondImmediateEndIndex);
+                result.secondImmediateDecoder.setBytes(secondImmediateBytes);
+                break;
+            }
+            case ArgumentType.ONE_REGISTER_TWO_IMMEDIATES: {
+                const firstByte = this.code[pc + 1];
+                this.nibblesDecoder.setByte(firstByte);
+                result.registerIndex = this.nibblesDecoder.getLowNibbleAsRegisterIndex();
+                const firstImmediateLength = this.nibblesDecoder.getHighNibbleAsLength();
+                const firstImmediateStartIndex = pc + 2;
+                const firstImmediateEndIndex = firstImmediateStartIndex + firstImmediateLength;
+                const firstImmediateBytes = this.code.subarray(firstImmediateStartIndex, firstImmediateEndIndex);
+                result.firstImmediateDecoder.setBytes(firstImmediateBytes);
+                const secondImmediateLength = Math.min(IMMEDIATE_AND_OFFSET_MAX_LENGTH, Math.max(0, nextInstructionDistance - 2 - firstImmediateLength));
+                const secondImmediateStartIndex = firstImmediateEndIndex;
+                const secondImmediateEndIndex = secondImmediateStartIndex + secondImmediateLength;
+                const secondImmediateBytes = this.code.subarray(secondImmediateStartIndex, secondImmediateEndIndex);
+                result.secondImmediateDecoder.setBytes(secondImmediateBytes);
+                break;
+            }
+            case ArgumentType.TWO_REGISTERS_TWO_IMMEDIATES: {
+                const firstByte = this.code[pc + 1];
+                this.nibblesDecoder.setByte(firstByte);
+                result.firstRegisterIndex = this.nibblesDecoder.getLowNibbleAsRegisterIndex();
+                result.secondRegisterIndex = this.nibblesDecoder.getHighNibbleAsRegisterIndex();
+                const secondByte = this.code[pc + 2];
+                this.nibblesDecoder.setByte(secondByte);
+                const firstImmediateLength = this.nibblesDecoder.getLowNibbleAsLength();
+                const firstImmediateStartIndex = pc + 3;
+                const firstImmediateEndIndex = firstImmediateStartIndex + firstImmediateLength;
+                const firstImmediateBytes = this.code.subarray(firstImmediateStartIndex, firstImmediateEndIndex);
+                result.firstImmediateDecoder.setBytes(firstImmediateBytes);
+                const secondImmediateLength = Math.min(IMMEDIATE_AND_OFFSET_MAX_LENGTH, Math.max(0, nextInstructionDistance - 3 - firstImmediateLength));
+                const secondImmediateStartIndex = firstImmediateEndIndex;
+                const secondImmediateEndIndex = secondImmediateStartIndex + secondImmediateLength;
+                const secondImmediateBytes = this.code.subarray(secondImmediateStartIndex, secondImmediateEndIndex);
+                result.secondImmediateDecoder.setBytes(secondImmediateBytes);
+                break;
+            }
+            case ArgumentType.ONE_REGISTER_ONE_EXTENDED_WIDTH_IMMEDIATE: {
+                const firstByte = this.code[pc + 1];
+                this.nibblesDecoder.setByte(firstByte);
+                result.registerIndex = this.nibblesDecoder.getLowNibbleAsRegisterIndex();
+                const immediateStartIndex = pc + 2;
+                const immediateEndIndex = immediateStartIndex + 8;
+                const immediateBytes = this.code.subarray(immediateStartIndex, immediateEndIndex);
+                result.immediateDecoder.setBytes(immediateBytes);
+                break;
+            }
         }
-        return (this.isInRange(other.start) ||
-            this.isInRange(other.lastIndex) ||
-            other.isInRange(this.start) ||
-            other.isInRange(this.lastIndex));
     }
 }
-/**
- * The first 16 pages of memory are reserved.
- *
- * https://graypaper.fluffylabs.dev/#/cc517d7/24d00024d000?v=0.6.5
- *
- * it should be in `memory-consts` but it cannot be there because of circular dependency
- */
-const RESERVED_MEMORY_RANGE = MemoryRange.fromStartAndLength(tryAsMemoryIndex(0), RESERVED_NUMBER_OF_PAGES * PAGE_SIZE$1);
 
-/**
- * A half-open range of memory pages. Similarly to [`MemoryRange`], can be empty
- * or wrapped around the memory.
- */
-class PageRange {
-    start;
-    length;
-    /**
-     * Exclusive end of the page range.
-     *
-     * NOTE: it may be smaller than `start` in case the range is wrapped.
-     */
-    end;
-    constructor(start, length) {
-        this.start = start;
-        this.length = length;
-        this.end = tryAsPageNumber((this.start + this.length) % MAX_NUMBER_OF_PAGES);
-    }
-    /**
-     * Creates range of pages that includes all indices in a given memory range.
-     *
-     * Example: For memory range `[PAGE_SIZE, MEMORY_SIZE - PAGE_SIZE)`
-     *                  we will get `[1, MAX_NUMBER_OF_PAGES - 1)` page range.
-     */
-    static fromMemoryRange(range) {
-        const startPage = getPageNumber(range.start);
-        if (range.isEmpty()) {
-            return new PageRange(startPage, 0);
-        }
-        // lastIndex is not null because we just ensured that the range is not empty
-        const pageWithLastIndex = getPageNumber(range.lastIndex ?? range.end);
-        const endPage = getNextPageNumber(pageWithLastIndex);
-        if ((startPage === endPage || startPage === pageWithLastIndex) && range.length > PAGE_SIZE$1) {
-            // full range
-            return new PageRange(startPage, MAX_NUMBER_OF_PAGES);
-        }
-        const length = startPage < endPage ? endPage - startPage : MAX_NUMBER_OF_PAGES - startPage + endPage;
-        return PageRange.fromStartAndLength(startPage, length);
+const IMMEDIATE_SIZE = 8;
+class ExtendedWitdthImmediateDecoder {
+    unsignedImmediate;
+    bytes;
+    constructor() {
+        const buffer = new ArrayBuffer(IMMEDIATE_SIZE);
+        this.unsignedImmediate = new BigUint64Array(buffer);
+        this.bytes = new Uint8Array(buffer);
     }
-    /** Creates a page range from given starting point and length */
-    static fromStartAndLength(start, length) {
-        if (!Number.isInteger(length) || length < 0 || length > MAX_NUMBER_OF_PAGES) {
-            throw new TypeError(`length must be a non-negative integer and less than ${MAX_NUMBER_OF_PAGES}, got ${length}`);
+    setBytes(bytes) {
+        let i = 0;
+        for (; i < bytes.length; i++) {
+            this.bytes[i] = bytes[i];
         }
-        return new PageRange(start, length);
-    }
-    /** Returns true if the page range is wrapped (`start` >= `end`) and is not empty */
-    isWrapped() {
-        return this.start >= this.end && !this.isEmpty();
-    }
-    /** Checks if given page number is within the range */
-    isInRange(page) {
-        if (this.isWrapped()) {
-            return page >= this.start || page < this.end;
+        for (; i < IMMEDIATE_SIZE; i++) {
+            this.bytes[i] = 0;
         }
-        return page >= this.start && page < this.end;
     }
-    /** Checks if a range is empty (`length === 0`) */
-    isEmpty() {
-        return this.length === 0;
+    getValue() {
+        return this.unsignedImmediate[0];
     }
-    *[Symbol.iterator]() {
-        if (this.isEmpty()) {
-            return;
-        }
-        const end = this.end;
-        let i = this.start;
-        do {
-            yield i;
-            i = getNextPageNumber(i);
-        } while (i !== end);
+    getBytesAsLittleEndian() {
+        return this.bytes.subarray(0, IMMEDIATE_SIZE);
     }
 }
 
-class MemoryPage {
-    start;
-    constructor(pageNumber) {
-        this.start = getStartPageIndexFromPageNumber(pageNumber);
-    }
-}
+const ARGUMENT_TYPE_LENGTH = Object.keys(ArgumentType).length / 2;
+const createResults = () => {
+    const results = new Array(ARGUMENT_TYPE_LENGTH);
+    results[ArgumentType.NO_ARGUMENTS] = {
+        type: ArgumentType.NO_ARGUMENTS,
+        noOfBytesToSkip: 1,
+    };
+    results[ArgumentType.ONE_IMMEDIATE] = {
+        type: ArgumentType.ONE_IMMEDIATE,
+        noOfBytesToSkip: 1,
+        immediateDecoder: new ImmediateDecoder(),
+    };
+    results[ArgumentType.TWO_REGISTERS] = {
+        type: ArgumentType.TWO_REGISTERS,
+        noOfBytesToSkip: 1,
+        firstRegisterIndex: 0,
+        secondRegisterIndex: 0,
+    };
+    results[ArgumentType.THREE_REGISTERS] = {
+        type: ArgumentType.THREE_REGISTERS,
+        noOfBytesToSkip: 1,
+        firstRegisterIndex: 0,
+        secondRegisterIndex: 0,
+        thirdRegisterIndex: 0,
+    };
+    results[ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET] = {
+        type: ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET,
+        noOfBytesToSkip: 1,
+        registerIndex: 0,
+        immediateDecoder: new ImmediateDecoder(),
+        nextPc: 0,
+    };
+    results[ArgumentType.TWO_REGISTERS_ONE_OFFSET] = {
+        type: ArgumentType.TWO_REGISTERS_ONE_OFFSET,
+        noOfBytesToSkip: 1,
+        firstRegisterIndex: 0,
+        secondRegisterIndex: 0,
+        nextPc: 0,
+    };
+    results[ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE] = {
+        type: ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE,
+        noOfBytesToSkip: 1,
+        firstRegisterIndex: 0,
+        secondRegisterIndex: 0,
+        immediateDecoder: new ImmediateDecoder(),
+    };
+    results[ArgumentType.ONE_REGISTER_ONE_IMMEDIATE] = {
+        type: ArgumentType.ONE_REGISTER_ONE_IMMEDIATE,
+        noOfBytesToSkip: 1,
+        registerIndex: 0,
+        immediateDecoder: new ImmediateDecoder(),
+    };
+    results[ArgumentType.ONE_REGISTER_TWO_IMMEDIATES] = {
+        type: ArgumentType.ONE_REGISTER_TWO_IMMEDIATES,
+        noOfBytesToSkip: 1,
+        registerIndex: 0,
+        firstImmediateDecoder: new ImmediateDecoder(),
+        secondImmediateDecoder: new ImmediateDecoder(),
+    };
+    results[ArgumentType.ONE_OFFSET] = {
+        type: ArgumentType.ONE_OFFSET,
+        noOfBytesToSkip: 1,
+        nextPc: 0,
+    };
+    results[ArgumentType.TWO_IMMEDIATES] = {
+        type: ArgumentType.TWO_IMMEDIATES,
+        noOfBytesToSkip: 1,
+        firstImmediateDecoder: new ImmediateDecoder(),
+        secondImmediateDecoder: new ImmediateDecoder(),
+    };
+    results[ArgumentType.TWO_REGISTERS_TWO_IMMEDIATES] = {
+        type: ArgumentType.TWO_REGISTERS_TWO_IMMEDIATES,
+        noOfBytesToSkip: 1,
+        firstImmediateDecoder: new ImmediateDecoder(),
+        secondImmediateDecoder: new ImmediateDecoder(),
+        firstRegisterIndex: 0,
+        secondRegisterIndex: 0,
+    };
+    results[ArgumentType.ONE_REGISTER_ONE_EXTENDED_WIDTH_IMMEDIATE] = {
+        type: ArgumentType.ONE_REGISTER_ONE_EXTENDED_WIDTH_IMMEDIATE,
+        noOfBytesToSkip: 9,
+        registerIndex: 0,
+        immediateDecoder: new ExtendedWitdthImmediateDecoder(),
+    };
+    return results;
+};
+
+var Instruction;
+(function (Instruction) {
+    Instruction[Instruction["TRAP"] = 0] = "TRAP";
+    Instruction[Instruction["FALLTHROUGH"] = 1] = "FALLTHROUGH";
+    Instruction[Instruction["ECALLI"] = 10] = "ECALLI";
+    Instruction[Instruction["LOAD_IMM_64"] = 20] = "LOAD_IMM_64";
+    Instruction[Instruction["STORE_IMM_U8"] = 30] = "STORE_IMM_U8";
+    Instruction[Instruction["STORE_IMM_U16"] = 31] = "STORE_IMM_U16";
+    Instruction[Instruction["STORE_IMM_U32"] = 32] = "STORE_IMM_U32";
+    Instruction[Instruction["STORE_IMM_U64"] = 33] = "STORE_IMM_U64";
+    Instruction[Instruction["JUMP"] = 40] = "JUMP";
+    Instruction[Instruction["JUMP_IND"] = 50] = "JUMP_IND";
+    Instruction[Instruction["LOAD_IMM"] = 51] = "LOAD_IMM";
+    Instruction[Instruction["LOAD_U8"] = 52] = "LOAD_U8";
+    Instruction[Instruction["LOAD_I8"] = 53] = "LOAD_I8";
+    Instruction[Instruction["LOAD_U16"] = 54] = "LOAD_U16";
+    Instruction[Instruction["LOAD_I16"] = 55] = "LOAD_I16";
+    Instruction[Instruction["LOAD_U32"] = 56] = "LOAD_U32";
+    Instruction[Instruction["LOAD_I32"] = 57] = "LOAD_I32";
+    Instruction[Instruction["LOAD_U64"] = 58] = "LOAD_U64";
+    Instruction[Instruction["STORE_U8"] = 59] = "STORE_U8";
+    Instruction[Instruction["STORE_U16"] = 60] = "STORE_U16";
+    Instruction[Instruction["STORE_U32"] = 61] = "STORE_U32";
+    Instruction[Instruction["STORE_U64"] = 62] = "STORE_U64";
+    Instruction[Instruction["STORE_IMM_IND_U8"] = 70] = "STORE_IMM_IND_U8";
+    Instruction[Instruction["STORE_IMM_IND_U16"] = 71] = "STORE_IMM_IND_U16";
+    Instruction[Instruction["STORE_IMM_IND_U32"] = 72] = "STORE_IMM_IND_U32";
+    Instruction[Instruction["STORE_IMM_IND_U64"] = 73] = "STORE_IMM_IND_U64";
+    Instruction[Instruction["LOAD_IMM_JUMP"] = 80] = "LOAD_IMM_JUMP";
+    Instruction[Instruction["BRANCH_EQ_IMM"] = 81] = "BRANCH_EQ_IMM";
+    Instruction[Instruction["BRANCH_NE_IMM"] = 82] = "BRANCH_NE_IMM";
+    Instruction[Instruction["BRANCH_LT_U_IMM"] = 83] = "BRANCH_LT_U_IMM";
+    Instruction[Instruction["BRANCH_LE_U_IMM"] = 84] = "BRANCH_LE_U_IMM";
+    Instruction[Instruction["BRANCH_GE_U_IMM"] = 85] = "BRANCH_GE_U_IMM";
+    Instruction[Instruction["BRANCH_GT_U_IMM"] = 86] = "BRANCH_GT_U_IMM";
+    Instruction[Instruction["BRANCH_LT_S_IMM"] = 87] = "BRANCH_LT_S_IMM";
+    Instruction[Instruction["BRANCH_LE_S_IMM"] = 88] = "BRANCH_LE_S_IMM";
+    Instruction[Instruction["BRANCH_GE_S_IMM"] = 89] = "BRANCH_GE_S_IMM";
+    Instruction[Instruction["BRANCH_GT_S_IMM"] = 90] = "BRANCH_GT_S_IMM";
+    Instruction[Instruction["MOVE_REG"] = 100] = "MOVE_REG";
+    Instruction[Instruction["SBRK"] = 101] = "SBRK";
+    Instruction[Instruction["COUNT_SET_BITS_64"] = 102] = "COUNT_SET_BITS_64";
+    Instruction[Instruction["COUNT_SET_BITS_32"] = 103] = "COUNT_SET_BITS_32";
+    Instruction[Instruction["LEADING_ZERO_BITS_64"] = 104] = "LEADING_ZERO_BITS_64";
+    Instruction[Instruction["LEADING_ZERO_BITS_32"] = 105] = "LEADING_ZERO_BITS_32";
+    Instruction[Instruction["TRAILING_ZERO_BITS_64"] = 106] = "TRAILING_ZERO_BITS_64";
+    Instruction[Instruction["TRAILING_ZERO_BITS_32"] = 107] = "TRAILING_ZERO_BITS_32";
+    Instruction[Instruction["SIGN_EXTEND_8"] = 108] = "SIGN_EXTEND_8";
+    Instruction[Instruction["SIGN_EXTEND_16"] = 109] = "SIGN_EXTEND_16";
+    Instruction[Instruction["ZERO_EXTEND_16"] = 110] = "ZERO_EXTEND_16";
+    Instruction[Instruction["REVERSE_BYTES"] = 111] = "REVERSE_BYTES";
+    Instruction[Instruction["STORE_IND_U8"] = 120] = "STORE_IND_U8";
+    Instruction[Instruction["STORE_IND_U16"] = 121] = "STORE_IND_U16";
+    Instruction[Instruction["STORE_IND_U32"] = 122] = "STORE_IND_U32";
+    Instruction[Instruction["STORE_IND_U64"] = 123] = "STORE_IND_U64";
+    Instruction[Instruction["LOAD_IND_U8"] = 124] = "LOAD_IND_U8";
+    Instruction[Instruction["LOAD_IND_I8"] = 125] = "LOAD_IND_I8";
+    Instruction[Instruction["LOAD_IND_U16"] = 126] = "LOAD_IND_U16";
+    Instruction[Instruction["LOAD_IND_I16"] = 127] = "LOAD_IND_I16";
+    Instruction[Instruction["LOAD_IND_U32"] = 128] = "LOAD_IND_U32";
+    Instruction[Instruction["LOAD_IND_I32"] = 129] = "LOAD_IND_I32";
+    Instruction[Instruction["LOAD_IND_U64"] = 130] = "LOAD_IND_U64";
+    Instruction[Instruction["ADD_IMM_32"] = 131] = "ADD_IMM_32";
+    Instruction[Instruction["AND_IMM"] = 132] = "AND_IMM";
+    Instruction[Instruction["XOR_IMM"] = 133] = "XOR_IMM";
+    Instruction[Instruction["OR_IMM"] = 134] = "OR_IMM";
+    Instruction[Instruction["MUL_IMM_32"] = 135] = "MUL_IMM_32";
+    Instruction[Instruction["SET_LT_U_IMM"] = 136] = "SET_LT_U_IMM";
+    Instruction[Instruction["SET_LT_S_IMM"] = 137] = "SET_LT_S_IMM";
+    Instruction[Instruction["SHLO_L_IMM_32"] = 138] = "SHLO_L_IMM_32";
+    Instruction[Instruction["SHLO_R_IMM_32"] = 139] = "SHLO_R_IMM_32";
+    Instruction[Instruction["SHAR_R_IMM_32"] = 140] = "SHAR_R_IMM_32";
+    Instruction[Instruction["NEG_ADD_IMM_32"] = 141] = "NEG_ADD_IMM_32";
+    Instruction[Instruction["SET_GT_U_IMM"] = 142] = "SET_GT_U_IMM";
+    Instruction[Instruction["SET_GT_S_IMM"] = 143] = "SET_GT_S_IMM";
+    Instruction[Instruction["SHLO_L_IMM_ALT_32"] = 144] = "SHLO_L_IMM_ALT_32";
+    Instruction[Instruction["SHLO_R_IMM_ALT_32"] = 145] = "SHLO_R_IMM_ALT_32";
+    Instruction[Instruction["SHAR_R_IMM_ALT_32"] = 146] = "SHAR_R_IMM_ALT_32";
+    Instruction[Instruction["CMOV_IZ_IMM"] = 147] = "CMOV_IZ_IMM";
+    Instruction[Instruction["CMOV_NZ_IMM"] = 148] = "CMOV_NZ_IMM";
+    Instruction[Instruction["ADD_IMM_64"] = 149] = "ADD_IMM_64";
+    Instruction[Instruction["MUL_IMM_64"] = 150] = "MUL_IMM_64";
+    Instruction[Instruction["SHLO_L_IMM_64"] = 151] = "SHLO_L_IMM_64";
+    Instruction[Instruction["SHLO_R_IMM_64"] = 152] = "SHLO_R_IMM_64";
+    Instruction[Instruction["SHAR_R_IMM_64"] = 153] = "SHAR_R_IMM_64";
+    Instruction[Instruction["NEG_ADD_IMM_64"] = 154] = "NEG_ADD_IMM_64";
+    Instruction[Instruction["SHLO_L_IMM_ALT_64"] = 155] = "SHLO_L_IMM_ALT_64";
+    Instruction[Instruction["SHLO_R_IMM_ALT_64"] = 156] = "SHLO_R_IMM_ALT_64";
+    Instruction[Instruction["SHAR_R_IMM_ALT_64"] = 157] = "SHAR_R_IMM_ALT_64";
+    Instruction[Instruction["ROT_R_64_IMM"] = 158] = "ROT_R_64_IMM";
+    Instruction[Instruction["ROT_R_64_IMM_ALT"] = 159] = "ROT_R_64_IMM_ALT";
+    Instruction[Instruction["ROT_R_32_IMM"] = 160] = "ROT_R_32_IMM";
+    Instruction[Instruction["ROT_R_32_IMM_ALT"] = 161] = "ROT_R_32_IMM_ALT";
+    Instruction[Instruction["BRANCH_EQ"] = 170] = "BRANCH_EQ";
+    Instruction[Instruction["BRANCH_NE"] = 171] = "BRANCH_NE";
+    Instruction[Instruction["BRANCH_LT_U"] = 172] = "BRANCH_LT_U";
+    Instruction[Instruction["BRANCH_LT_S"] = 173] = "BRANCH_LT_S";
+    Instruction[Instruction["BRANCH_GE_U"] = 174] = "BRANCH_GE_U";
+    Instruction[Instruction["BRANCH_GE_S"] = 175] = "BRANCH_GE_S";
+    Instruction[Instruction["LOAD_IMM_JUMP_IND"] = 180] = "LOAD_IMM_JUMP_IND";
+    Instruction[Instruction["ADD_32"] = 190] = "ADD_32";
+    Instruction[Instruction["SUB_32"] = 191] = "SUB_32";
+    Instruction[Instruction["MUL_32"] = 192] = "MUL_32";
+    Instruction[Instruction["DIV_U_32"] = 193] = "DIV_U_32";
+    Instruction[Instruction["DIV_S_32"] = 194] = "DIV_S_32";
+    Instruction[Instruction["REM_U_32"] = 195] = "REM_U_32";
+    Instruction[Instruction["REM_S_32"] = 196] = "REM_S_32";
+    Instruction[Instruction["SHLO_L_32"] = 197] = "SHLO_L_32";
+    Instruction[Instruction["SHLO_R_32"] = 198] = "SHLO_R_32";
+    Instruction[Instruction["SHAR_R_32"] = 199] = "SHAR_R_32";
+    Instruction[Instruction["ADD_64"] = 200] = "ADD_64";
+    Instruction[Instruction["SUB_64"] = 201] = "SUB_64";
+    Instruction[Instruction["MUL_64"] = 202] = "MUL_64";
+    Instruction[Instruction["DIV_U_64"] = 203] = "DIV_U_64";
+    Instruction[Instruction["DIV_S_64"] = 204] = "DIV_S_64";
+    Instruction[Instruction["REM_U_64"] = 205] = "REM_U_64";
+    Instruction[Instruction["REM_S_64"] = 206] = "REM_S_64";
+    Instruction[Instruction["SHLO_L_64"] = 207] = "SHLO_L_64";
+    Instruction[Instruction["SHLO_R_64"] = 208] = "SHLO_R_64";
+    Instruction[Instruction["SHAR_R_64"] = 209] = "SHAR_R_64";
+    Instruction[Instruction["AND"] = 210] = "AND";
+    Instruction[Instruction["XOR"] = 211] = "XOR";
+    Instruction[Instruction["OR"] = 212] = "OR";
+    Instruction[Instruction["MUL_UPPER_S_S"] = 213] = "MUL_UPPER_S_S";
+    Instruction[Instruction["MUL_UPPER_U_U"] = 214] = "MUL_UPPER_U_U";
+    Instruction[Instruction["MUL_UPPER_S_U"] = 215] = "MUL_UPPER_S_U";
+    Instruction[Instruction["SET_LT_U"] = 216] = "SET_LT_U";
+    Instruction[Instruction["SET_LT_S"] = 217] = "SET_LT_S";
+    Instruction[Instruction["CMOV_IZ"] = 218] = "CMOV_IZ";
+    Instruction[Instruction["CMOV_NZ"] = 219] = "CMOV_NZ";
+    Instruction[Instruction["ROT_L_64"] = 220] = "ROT_L_64";
+    Instruction[Instruction["ROT_L_32"] = 221] = "ROT_L_32";
+    Instruction[Instruction["ROT_R_64"] = 222] = "ROT_R_64";
+    Instruction[Instruction["ROT_R_32"] = 223] = "ROT_R_32";
+    Instruction[Instruction["AND_INV"] = 224] = "AND_INV";
+    Instruction[Instruction["OR_INV"] = 225] = "OR_INV";
+    Instruction[Instruction["XNOR"] = 226] = "XNOR";
+    Instruction[Instruction["MAX"] = 227] = "MAX";
+    Instruction[Instruction["MAX_U"] = 228] = "MAX_U";
+    Instruction[Instruction["MIN"] = 229] = "MIN";
+    Instruction[Instruction["MIN_U"] = 230] = "MIN_U";
+})(Instruction || (Instruction = {}));
+const HIGHEST_INSTRUCTION_NUMBER = Instruction.MIN_U;
 
-class ReadablePage extends MemoryPage {
-    data;
-    constructor(pageNumber, data) {
-        super(pageNumber);
-        this.data = data;
-    }
-    loadInto(result, startIndex, length) {
-        const endIndex = startIndex + length;
-        if (endIndex > PAGE_SIZE$1) {
-            return Result$1.error(PageFault.fromMemoryIndex(this.start + PAGE_SIZE$1), () => `Page fault: read beyond page boundary at ${this.start + PAGE_SIZE$1}`);
-        }
-        const bytes = this.data.subarray(startIndex, endIndex);
-        // we zero the bytes, since data might not yet be initialized at `endIndex`.
-        result.fill(0, bytes.length, length);
-        result.set(bytes);
-        return Result$1.ok(OK);
-    }
-    storeFrom(_address, _data) {
-        return Result$1.error(PageFault.fromMemoryIndex(this.start, true), () => `Page fault: attempted to write to read-only page at ${this.start}`);
-    }
-    setData(pageIndex, data) {
-        this.data.set(data, pageIndex);
-    }
-    isWriteable() {
-        return false;
-    }
-    getPageDump() {
-        return this.data;
-    }
-}
+const instructionArgumentTypeMap = (() => {
+    const instructionArgumentTypeMap = new Array(HIGHEST_INSTRUCTION_NUMBER + 1);
+    instructionArgumentTypeMap[Instruction.TRAP] = ArgumentType.NO_ARGUMENTS;
+    instructionArgumentTypeMap[Instruction.FALLTHROUGH] = ArgumentType.NO_ARGUMENTS;
+    instructionArgumentTypeMap[Instruction.ECALLI] = ArgumentType.ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.LOAD_IMM_64] = ArgumentType.ONE_REGISTER_ONE_EXTENDED_WIDTH_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.STORE_IMM_U8] = ArgumentType.TWO_IMMEDIATES;
+    instructionArgumentTypeMap[Instruction.STORE_IMM_U16] = ArgumentType.TWO_IMMEDIATES;
+    instructionArgumentTypeMap[Instruction.STORE_IMM_U32] = ArgumentType.TWO_IMMEDIATES;
+    instructionArgumentTypeMap[Instruction.STORE_IMM_U64] = ArgumentType.TWO_IMMEDIATES;
+    instructionArgumentTypeMap[Instruction.JUMP] = ArgumentType.ONE_OFFSET;
+    instructionArgumentTypeMap[Instruction.JUMP_IND] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.LOAD_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.LOAD_U8] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.LOAD_I8] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.LOAD_U16] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.LOAD_I16] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.LOAD_U32] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.LOAD_I32] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.LOAD_U64] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.STORE_U8] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.STORE_U16] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.STORE_U32] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.STORE_U64] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.STORE_IMM_IND_U8] = ArgumentType.ONE_REGISTER_TWO_IMMEDIATES;
+    instructionArgumentTypeMap[Instruction.STORE_IMM_IND_U16] = ArgumentType.ONE_REGISTER_TWO_IMMEDIATES;
+    instructionArgumentTypeMap[Instruction.STORE_IMM_IND_U32] = ArgumentType.ONE_REGISTER_TWO_IMMEDIATES;
+    instructionArgumentTypeMap[Instruction.STORE_IMM_IND_U64] = ArgumentType.ONE_REGISTER_TWO_IMMEDIATES;
+    instructionArgumentTypeMap[Instruction.LOAD_IMM_JUMP] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
+    instructionArgumentTypeMap[Instruction.BRANCH_EQ_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
+    instructionArgumentTypeMap[Instruction.BRANCH_NE_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
+    instructionArgumentTypeMap[Instruction.BRANCH_LT_U_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
+    instructionArgumentTypeMap[Instruction.BRANCH_LE_U_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
+    instructionArgumentTypeMap[Instruction.BRANCH_GE_U_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
+    instructionArgumentTypeMap[Instruction.BRANCH_GT_U_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
+    instructionArgumentTypeMap[Instruction.BRANCH_LT_S_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
+    instructionArgumentTypeMap[Instruction.BRANCH_LE_S_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
+    instructionArgumentTypeMap[Instruction.BRANCH_GE_S_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
+    instructionArgumentTypeMap[Instruction.BRANCH_GT_S_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
+    instructionArgumentTypeMap[Instruction.MOVE_REG] = ArgumentType.TWO_REGISTERS;
+    instructionArgumentTypeMap[Instruction.SBRK] = ArgumentType.TWO_REGISTERS;
+    instructionArgumentTypeMap[Instruction.COUNT_SET_BITS_64] = ArgumentType.TWO_REGISTERS;
+    instructionArgumentTypeMap[Instruction.COUNT_SET_BITS_32] = ArgumentType.TWO_REGISTERS;
+    instructionArgumentTypeMap[Instruction.LEADING_ZERO_BITS_64] = ArgumentType.TWO_REGISTERS;
+    instructionArgumentTypeMap[Instruction.LEADING_ZERO_BITS_32] = ArgumentType.TWO_REGISTERS;
+    instructionArgumentTypeMap[Instruction.TRAILING_ZERO_BITS_64] = ArgumentType.TWO_REGISTERS;
+    instructionArgumentTypeMap[Instruction.TRAILING_ZERO_BITS_32] = ArgumentType.TWO_REGISTERS;
+    instructionArgumentTypeMap[Instruction.SIGN_EXTEND_8] = ArgumentType.TWO_REGISTERS;
+    instructionArgumentTypeMap[Instruction.SIGN_EXTEND_16] = ArgumentType.TWO_REGISTERS;
+    instructionArgumentTypeMap[Instruction.ZERO_EXTEND_16] = ArgumentType.TWO_REGISTERS;
+    instructionArgumentTypeMap[Instruction.REVERSE_BYTES] = ArgumentType.TWO_REGISTERS;
+    instructionArgumentTypeMap[Instruction.STORE_IND_U8] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.STORE_IND_U16] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.STORE_IND_U32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.STORE_IND_U64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.LOAD_IND_U8] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.LOAD_IND_I8] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.LOAD_IND_U16] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.LOAD_IND_I16] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.LOAD_IND_U32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.LOAD_IND_I32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.LOAD_IND_U64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.ADD_IMM_32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.ADD_IMM_64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.AND_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.XOR_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.OR_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.MUL_IMM_32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.MUL_IMM_64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.SET_LT_U_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.SET_LT_S_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.SHLO_L_IMM_32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.SHLO_R_IMM_32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.SHAR_R_IMM_32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.NEG_ADD_IMM_32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.SHLO_L_IMM_64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.SHLO_R_IMM_64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.SHAR_R_IMM_64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.NEG_ADD_IMM_64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.SET_GT_U_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.SET_GT_S_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.SHLO_L_IMM_ALT_32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.SHLO_R_IMM_ALT_32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.SHAR_R_IMM_ALT_32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.SHLO_L_IMM_ALT_64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.SHLO_R_IMM_ALT_64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.SHAR_R_IMM_ALT_64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.CMOV_IZ_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.CMOV_NZ_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.ROT_R_64_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.ROT_R_64_IMM_ALT] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.ROT_R_32_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.ROT_R_32_IMM_ALT] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[Instruction.BRANCH_EQ] = ArgumentType.TWO_REGISTERS_ONE_OFFSET;
+    instructionArgumentTypeMap[Instruction.BRANCH_NE] = ArgumentType.TWO_REGISTERS_ONE_OFFSET;
+    instructionArgumentTypeMap[Instruction.BRANCH_LT_U] = ArgumentType.TWO_REGISTERS_ONE_OFFSET;
+    instructionArgumentTypeMap[Instruction.BRANCH_LT_S] = ArgumentType.TWO_REGISTERS_ONE_OFFSET;
+    instructionArgumentTypeMap[Instruction.BRANCH_GE_U] = ArgumentType.TWO_REGISTERS_ONE_OFFSET;
+    instructionArgumentTypeMap[Instruction.BRANCH_GE_S] = ArgumentType.TWO_REGISTERS_ONE_OFFSET;
+    instructionArgumentTypeMap[Instruction.LOAD_IMM_JUMP_IND] = ArgumentType.TWO_REGISTERS_TWO_IMMEDIATES;
+    instructionArgumentTypeMap[Instruction.ADD_32] = ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[Instruction.ADD_64] = ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[Instruction.SUB_32] = ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[Instruction.SUB_64] = ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[Instruction.AND] = ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[Instruction.XOR] = ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[Instruction.OR] = ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[Instruction.MUL_32] = ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[Instruction.MUL_64] = ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[Instruction.MUL_UPPER_S_S] = ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[Instruction.MUL_UPPER_U_U] = ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[Instruction.MUL_UPPER_S_U] = ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[Instruction.DIV_U_32] = ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[Instruction.DIV_S_32] = ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[Instruction.REM_U_32] = ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[Instruction.REM_S_32] = ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[Instruction.DIV_U_64] = ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[Instruction.DIV_S_64] = ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[Instruction.REM_U_64] = ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[Instruction.REM_S_64] = ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[Instruction.SET_LT_U] = ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[Instruction.SET_LT_S] = ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[Instruction.SHLO_L_32] = ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[Instruction.SHLO_R_32] = ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[Instruction.SHAR_R_32] = ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[Instruction.SHLO_L_64] = ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[Instruction.SHLO_R_64] = ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[Instruction.SHAR_R_64] = ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[Instruction.CMOV_IZ] = ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[Instruction.CMOV_NZ] = ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[Instruction.ROT_L_64] = ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[Instruction.ROT_L_32] = ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[Instruction.ROT_R_64] = ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[Instruction.ROT_R_32] = ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[Instruction.AND_INV] = ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[Instruction.OR_INV] = ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[Instruction.XNOR] = ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[Instruction.MAX] = ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[Instruction.MAX_U] = ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[Instruction.MIN] = ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[Instruction.MIN_U] = ArgumentType.THREE_REGISTERS;
+    return instructionArgumentTypeMap;
+})();
 
-class WriteablePage extends MemoryPage {
-    buffer;
-    view;
-    constructor(pageNumber, initialData) {
-        super(pageNumber);
-        const dataLength = initialData?.length ?? 0;
-        const initialPageLength = Math.min(PAGE_SIZE$1, Math.max(dataLength, MIN_ALLOCATION_LENGTH));
-        this.buffer = new ArrayBuffer(initialPageLength, { maxByteLength: PAGE_SIZE$1 });
-        this.view = new Uint8Array(this.buffer);
-        if (initialData !== undefined) {
-            this.view.set(initialData);
-        }
-    }
-    loadInto(result, startIndex, length) {
-        const endIndex = startIndex + length;
-        if (endIndex > PAGE_SIZE$1) {
-            return Result$1.error(PageFault.fromMemoryIndex(this.start + PAGE_SIZE$1), () => `Page fault: read beyond page boundary at ${this.start + PAGE_SIZE$1}`);
-        }
-        const bytes = this.view.subarray(startIndex, endIndex);
-        // we zero the bytes, since the view might not yet be initialized at `endIndex`.
-        result.fill(0, bytes.length, length);
-        result.set(bytes);
-        return Result$1.ok(OK);
-    }
-    storeFrom(startIndex, bytes) {
-        if (this.buffer.byteLength < startIndex + bytes.length && this.buffer.byteLength < PAGE_SIZE$1) {
-            const newLength = Math.min(PAGE_SIZE$1, Math.max(MIN_ALLOCATION_LENGTH, startIndex + bytes.length));
-            this.buffer.resize(newLength);
+const instructionsWithoutArgs = [
+    [Instruction.TRAP, 1],
+    [Instruction.FALLTHROUGH, 1],
+];
+const instructionsWithOneImmediate = [[Instruction.ECALLI, 1]];
+const instructionsWithOneRegisterAndOneExtendedWidthImmediate = [[Instruction.LOAD_IMM_64, 1]];
+const instructionsWithTwoImmediates = [
+    [Instruction.STORE_IMM_U8, 1],
+    [Instruction.STORE_IMM_U16, 1],
+    [Instruction.STORE_IMM_U32, 1],
+    [Instruction.STORE_IMM_U64, 1],
+];
+const instructionsWithOneOffset = [[Instruction.JUMP, 1]];
+const instructionsWithOneRegisterAndOneImmediate = [
+    [Instruction.JUMP_IND, 1],
+    [Instruction.LOAD_IMM, 1],
+    [Instruction.LOAD_U8, 1],
+    [Instruction.LOAD_I8, 1],
+    [Instruction.LOAD_U16, 1],
+    [Instruction.LOAD_I16, 1],
+    [Instruction.LOAD_U32, 1],
+    [Instruction.LOAD_I32, 1],
+    [Instruction.LOAD_U64, 1],
+    [Instruction.STORE_U8, 1],
+    [Instruction.STORE_U16, 1],
+    [Instruction.STORE_U32, 1],
+    [Instruction.STORE_U64, 1],
+];
+const instructionsWithOneRegisterAndTwoImmediate = [
+    [Instruction.STORE_IMM_IND_U8, 1],
+    [Instruction.STORE_IMM_IND_U16, 1],
+    [Instruction.STORE_IMM_IND_U32, 1],
+    [Instruction.STORE_IMM_IND_U64, 1],
+];
+const instructionsWithOneRegisterOneImmediateAndOneOffset = [
+    [Instruction.LOAD_IMM_JUMP, 1],
+    [Instruction.BRANCH_EQ_IMM, 1],
+    [Instruction.BRANCH_NE_IMM, 1],
+    [Instruction.BRANCH_LT_U_IMM, 1],
+    [Instruction.BRANCH_LE_U_IMM, 1],
+    [Instruction.BRANCH_GE_U_IMM, 1],
+    [Instruction.BRANCH_GT_U_IMM, 1],
+    [Instruction.BRANCH_LT_S_IMM, 1],
+    [Instruction.BRANCH_LE_S_IMM, 1],
+    [Instruction.BRANCH_GE_S_IMM, 1],
+    [Instruction.BRANCH_GT_S_IMM, 1],
+];
+const instructionsWithTwoRegisters = [
+    [Instruction.MOVE_REG, 1],
+    [Instruction.SBRK, 1],
+    [Instruction.COUNT_SET_BITS_64, 1],
+    [Instruction.COUNT_SET_BITS_32, 1],
+    [Instruction.LEADING_ZERO_BITS_64, 1],
+    [Instruction.LEADING_ZERO_BITS_32, 1],
+    [Instruction.TRAILING_ZERO_BITS_64, 1],
+    [Instruction.TRAILING_ZERO_BITS_32, 1],
+    [Instruction.SIGN_EXTEND_8, 1],
+    [Instruction.SIGN_EXTEND_16, 1],
+    [Instruction.ZERO_EXTEND_16, 1],
+    [Instruction.REVERSE_BYTES, 1],
+];
+const instructionsWithTwoRegistersAndOneImmediate = [
+    [Instruction.STORE_IND_U8, 1],
+    [Instruction.STORE_IND_U16, 1],
+    [Instruction.STORE_IND_U32, 1],
+    [Instruction.STORE_IND_U64, 1],
+    [Instruction.LOAD_IND_U8, 1],
+    [Instruction.LOAD_IND_I8, 1],
+    [Instruction.LOAD_IND_U16, 1],
+    [Instruction.LOAD_IND_I16, 1],
+    [Instruction.LOAD_IND_U32, 1],
+    [Instruction.LOAD_IND_I32, 1],
+    [Instruction.LOAD_IND_U64, 1],
+    [Instruction.ADD_IMM_32, 1],
+    [Instruction.AND_IMM, 1],
+    [Instruction.XOR_IMM, 1],
+    [Instruction.OR_IMM, 1],
+    [Instruction.MUL_IMM_32, 1],
+    [Instruction.SET_LT_U_IMM, 1],
+    [Instruction.SET_LT_S_IMM, 1],
+    [Instruction.SHLO_L_IMM_32, 1],
+    [Instruction.SHLO_R_IMM_32, 1],
+    [Instruction.SHAR_R_IMM_32, 1],
+    [Instruction.NEG_ADD_IMM_32, 1],
+    [Instruction.SET_GT_U_IMM, 1],
+    [Instruction.SET_GT_S_IMM, 1],
+    [Instruction.SHLO_L_IMM_ALT_32, 1],
+    [Instruction.SHLO_R_IMM_ALT_32, 1],
+    [Instruction.SHAR_R_IMM_ALT_32, 1],
+    [Instruction.CMOV_IZ_IMM, 1],
+    [Instruction.CMOV_NZ_IMM, 1],
+    [Instruction.ADD_IMM_64, 1],
+    [Instruction.MUL_IMM_64, 1],
+    [Instruction.SHLO_L_IMM_64, 1],
+    [Instruction.SHLO_R_IMM_64, 1],
+    [Instruction.SHAR_R_IMM_64, 1],
+    [Instruction.NEG_ADD_IMM_64, 1],
+    [Instruction.SHLO_L_IMM_ALT_64, 1],
+    [Instruction.SHLO_R_IMM_ALT_64, 1],
+    [Instruction.SHAR_R_IMM_ALT_64, 1],
+    [Instruction.ROT_R_64_IMM, 1],
+    [Instruction.ROT_R_64_IMM_ALT, 1],
+    [Instruction.ROT_R_32_IMM, 1],
+    [Instruction.ROT_R_32_IMM_ALT, 1],
+];
+const instructionsWithTwoRegistersAndOneOffset = [
+    [Instruction.BRANCH_EQ, 1],
+    [Instruction.BRANCH_NE, 1],
+    [Instruction.BRANCH_LT_U, 1],
+    [Instruction.BRANCH_LT_S, 1],
+    [Instruction.BRANCH_GE_U, 1],
+    [Instruction.BRANCH_GE_S, 1],
+];
+const instructionWithTwoRegistersAndTwoImmediates = [[Instruction.LOAD_IMM_JUMP_IND, 1]];
+const instructionsWithThreeRegisters = [
+    [Instruction.ADD_32, 1],
+    [Instruction.SUB_32, 1],
+    [Instruction.MUL_32, 1],
+    [Instruction.DIV_U_32, 1],
+    [Instruction.DIV_S_32, 1],
+    [Instruction.REM_U_32, 1],
+    [Instruction.REM_S_32, 1],
+    [Instruction.SHLO_L_32, 1],
+    [Instruction.SHLO_R_32, 1],
+    [Instruction.SHAR_R_32, 1],
+    [Instruction.ADD_64, 1],
+    [Instruction.SUB_64, 1],
+    [Instruction.MUL_64, 1],
+    [Instruction.DIV_U_64, 1],
+    [Instruction.DIV_S_64, 1],
+    [Instruction.REM_U_64, 1],
+    [Instruction.REM_S_64, 1],
+    [Instruction.SHLO_L_64, 1],
+    [Instruction.SHLO_R_64, 1],
+    [Instruction.SHAR_R_64, 1],
+    [Instruction.AND, 1],
+    [Instruction.XOR, 1],
+    [Instruction.OR, 1],
+    [Instruction.MUL_UPPER_S_S, 1],
+    [Instruction.MUL_UPPER_U_U, 1],
+    [Instruction.MUL_UPPER_S_U, 1],
+    [Instruction.SET_LT_U, 1],
+    [Instruction.SET_LT_S, 1],
+    [Instruction.CMOV_IZ, 1],
+    [Instruction.CMOV_NZ, 1],
+    [Instruction.ROT_L_64, 1],
+    [Instruction.ROT_L_32, 1],
+    [Instruction.ROT_R_64, 1],
+    [Instruction.ROT_R_32, 1],
+    [Instruction.AND_INV, 1],
+    [Instruction.OR_INV, 1],
+    [Instruction.XNOR, 1],
+    [Instruction.MAX, 1],
+    [Instruction.MAX_U, 1],
+    [Instruction.MIN, 1],
+    [Instruction.MIN_U, 1],
+];
+const instructions = [
+    ...instructionsWithoutArgs,
+    ...instructionsWithOneImmediate,
+    ...instructionsWithOneRegisterAndOneExtendedWidthImmediate,
+    ...instructionsWithTwoImmediates,
+    ...instructionsWithOneOffset,
+    ...instructionsWithOneRegisterAndOneImmediate,
+    ...instructionsWithOneRegisterAndTwoImmediate,
+    ...instructionsWithOneRegisterOneImmediateAndOneOffset,
+    ...instructionsWithTwoRegisters,
+    ...instructionsWithTwoRegistersAndOneImmediate,
+    ...instructionsWithTwoRegistersAndOneOffset,
+    ...instructionWithTwoRegistersAndTwoImmediates,
+    ...instructionsWithThreeRegisters,
+];
+const createOpCodeEntry = ([byte, gas]) => [byte, { gas: tryAsSmallGas(gas) }];
+const byteToOpCodeMap = instructions.reduce((acc, instruction) => {
+    const [byte, opCode] = createOpCodeEntry(instruction);
+    acc[byte] = opCode;
+    return acc;
+}, {});
+function assemblify(program, mask) {
+    return program.reduce((acc, byte, index) => {
+        if (mask.isInstruction(index)) {
+            acc.push([Instruction[byte]]);
         }
-        this.view.set(bytes, startIndex);
-        return Result$1.ok(OK);
-    }
-    setData(pageIndex, data) {
-        if (this.buffer.byteLength < pageIndex + data.length && this.buffer.byteLength < PAGE_SIZE$1) {
-            const newLength = Math.min(PAGE_SIZE$1, Math.max(MIN_ALLOCATION_LENGTH, pageIndex + data.length));
-            this.buffer.resize(newLength);
+        else {
+            acc[acc.length - 1].push(byte);
         }
-        this.view.set(data, pageIndex);
-    }
-    isWriteable() {
-        return true;
-    }
-    getPageDump() {
-        return this.view;
-    }
+        return acc;
+    }, []);
 }
 
-var AccessType;
-(function (AccessType) {
-    AccessType[AccessType["READ"] = 0] = "READ";
-    AccessType[AccessType["WRITE"] = 1] = "WRITE";
-})(AccessType || (AccessType = {}));
-const logger$3 = Logger.new(import.meta.filename, "pvm:mem");
-class Memory {
-    sbrkIndex;
-    virtualSbrkIndex;
-    endHeapIndex;
-    memory;
-    static fromInitialMemory(initialMemoryState) {
-        return new Memory(initialMemoryState?.sbrkIndex, initialMemoryState?.sbrkIndex, initialMemoryState?.endHeapIndex, initialMemoryState?.memory);
-    }
-    constructor(sbrkIndex = tryAsSbrkIndex(RESERVED_MEMORY_RANGE.end), virtualSbrkIndex = tryAsSbrkIndex(RESERVED_MEMORY_RANGE.end), endHeapIndex = tryAsSbrkIndex(MAX_MEMORY_INDEX), memory = new Map()) {
-        this.sbrkIndex = sbrkIndex;
-        this.virtualSbrkIndex = virtualSbrkIndex;
-        this.endHeapIndex = endHeapIndex;
-        this.memory = memory;
-    }
-    reset() {
-        this.sbrkIndex = tryAsSbrkIndex(RESERVED_MEMORY_RANGE.end);
-        this.virtualSbrkIndex = tryAsSbrkIndex(RESERVED_MEMORY_RANGE.end);
-        this.endHeapIndex = tryAsSbrkIndex(MAX_MEMORY_INDEX);
-        this.memory = new Map(); // TODO [MaSi]: We should keep allocated pages somewhere and reuse it when it is possible
-    }
-    copyFrom(memory) {
-        this.sbrkIndex = memory.sbrkIndex;
-        this.virtualSbrkIndex = memory.virtualSbrkIndex;
-        this.endHeapIndex = memory.endHeapIndex;
-        this.memory = memory.memory;
-    }
-    storeFrom(address, bytes) {
-        if (bytes.length === 0) {
-            return Result$1.ok(OK);
-        }
-        logger$3.insane `MEM[${address}] <- ${BytesBlob.blobFrom(bytes)}`;
-        const pagesResult = this.getPages(address, bytes.length, AccessType.WRITE);
-        if (pagesResult.isError) {
-            return Result$1.error(pagesResult.error, pagesResult.details);
-        }
-        const pages = pagesResult.ok;
-        let currentPosition = address;
-        let bytesLeft = bytes.length;
-        for (const page of pages) {
-            const pageStartIndex = tryAsPageIndex(currentPosition % PAGE_SIZE$1);
-            const bytesToWrite = Math.min(PAGE_SIZE$1 - pageStartIndex, bytesLeft);
-            const sourceStartIndex = currentPosition - address;
-            const source = bytes.subarray(sourceStartIndex, sourceStartIndex + bytesToWrite);
-            page.storeFrom(pageStartIndex, source);
-            currentPosition += bytesToWrite;
-            bytesLeft -= bytesToWrite;
-        }
-        return Result$1.ok(OK);
-    }
-    getPages(startAddress, length, accessType) {
-        if (length === 0) {
-            return Result$1.ok([]);
-        }
-        const memoryRange = MemoryRange.fromStartAndLength(startAddress, length);
-        const pageRange = PageRange.fromMemoryRange(memoryRange);
-        const pages = [];
-        for (const pageNumber of pageRange) {
-            if (pageNumber < RESERVED_NUMBER_OF_PAGES) {
-                return Result$1.error(PageFault.fromPageNumber(pageNumber, true), () => `Page fault: attempted to access reserved page ${pageNumber}`);
-            }
-            const page = this.memory.get(pageNumber);
-            if (page === undefined) {
-                return Result$1.error(PageFault.fromPageNumber(pageNumber), () => `Page fault: page ${pageNumber} not allocated`);
-            }
-            if (accessType === AccessType.WRITE && !page.isWriteable()) {
-                return Result$1.error(PageFault.fromPageNumber(pageNumber, true), () => `Page fault: attempted to write to read-only page ${pageNumber}`);
+const terminationInstructions = (() => {
+    const terminationInstructions = new Array(HIGHEST_INSTRUCTION_NUMBER + 1);
+    terminationInstructions.fill(false);
+    terminationInstructions[Instruction.TRAP] = true;
+    terminationInstructions[Instruction.FALLTHROUGH] = true;
+    terminationInstructions[Instruction.JUMP] = true;
+    terminationInstructions[Instruction.JUMP_IND] = true;
+    terminationInstructions[Instruction.LOAD_IMM_JUMP] = true;
+    terminationInstructions[Instruction.LOAD_IMM_JUMP_IND] = true;
+    terminationInstructions[Instruction.BRANCH_EQ] = true;
+    terminationInstructions[Instruction.BRANCH_NE] = true;
+    terminationInstructions[Instruction.BRANCH_GE_U] = true;
+    terminationInstructions[Instruction.BRANCH_GE_S] = true;
+    terminationInstructions[Instruction.BRANCH_LT_U] = true;
+    terminationInstructions[Instruction.BRANCH_LT_S] = true;
+    terminationInstructions[Instruction.BRANCH_EQ_IMM] = true;
+    terminationInstructions[Instruction.BRANCH_NE_IMM] = true;
+    terminationInstructions[Instruction.BRANCH_LT_U_IMM] = true;
+    terminationInstructions[Instruction.BRANCH_LT_S_IMM] = true;
+    terminationInstructions[Instruction.BRANCH_LE_U_IMM] = true;
+    terminationInstructions[Instruction.BRANCH_LE_S_IMM] = true;
+    terminationInstructions[Instruction.BRANCH_GE_U_IMM] = true;
+    terminationInstructions[Instruction.BRANCH_GE_S_IMM] = true;
+    terminationInstructions[Instruction.BRANCH_GT_U_IMM] = true;
+    terminationInstructions[Instruction.BRANCH_GT_S_IMM] = true;
+    return terminationInstructions;
+})();
+
+class BasicBlocks {
+    basicBlocks = new Set();
+    reset(code, mask) {
+        this.basicBlocks.clear();
+        this.basicBlocks.add(0);
+        const codeLength = code.length;
+        const isBasicBlockTermination = (index) => mask.isInstruction(index) && terminationInstructions[code[index]];
+        for (let i = 0; i < codeLength; i++) {
+            if (mask.isInstruction(i) && isBasicBlockTermination(i)) {
+                this.basicBlocks.add(i + 1 + mask.getNoOfBytesToNextInstruction(i + 1));
             }
-            pages.push(page);
-        }
-        return Result$1.ok(pages);
-    }
-    /**
-     * Read content of the memory at `[address, address + result.length)` and
-     * write the result into the `result` buffer.
-     *
-     * Returns `null` if the data was read successfully or `PageFault` otherwise.
-     */
-    loadInto(result, startAddress) {
-        if (result.length === 0) {
-            return Result$1.ok(OK);
-        }
-        const pagesResult = this.getPages(startAddress, result.length, AccessType.READ);
-        if (pagesResult.isError) {
-            return Result$1.error(pagesResult.error, pagesResult.details);
-        }
-        const pages = pagesResult.ok;
-        let currentPosition = startAddress;
-        let bytesLeft = result.length;
-        for (const page of pages) {
-            const pageStartIndex = tryAsPageIndex(currentPosition % PAGE_SIZE$1);
-            const bytesToRead = Math.min(PAGE_SIZE$1 - pageStartIndex, bytesLeft);
-            const destinationStartIndex = currentPosition - startAddress;
-            const destination = result.subarray(destinationStartIndex);
-            page.loadInto(destination, pageStartIndex, bytesToRead);
-            currentPosition += bytesToRead;
-            bytesLeft -= bytesToRead;
-        }
-        logger$3.insane `MEM[${startAddress}] => ${BytesBlob.blobFrom(result)}`;
-        return Result$1.ok(OK);
-    }
-    sbrk(length) {
-        const currentSbrkIndex = this.sbrkIndex;
-        const currentVirtualSbrkIndex = this.virtualSbrkIndex;
-        // new sbrk index is bigger than 2 ** 32 or endHeapIndex
-        if (MAX_MEMORY_INDEX < currentVirtualSbrkIndex + length || currentVirtualSbrkIndex + length > this.endHeapIndex) {
-            throw new OutOfMemory();
-        }
-        const newVirtualSbrkIndex = tryAsSbrkIndex(this.virtualSbrkIndex + length);
-        // no alllocation needed
-        if (newVirtualSbrkIndex <= currentSbrkIndex) {
-            this.virtualSbrkIndex = newVirtualSbrkIndex;
-            return currentVirtualSbrkIndex;
-        }
-        // standard allocation using "Writeable" pages
-        const newSbrkIndex = tryAsSbrkIndex(alignToPageSize$1(newVirtualSbrkIndex));
-        // TODO [MaSi]: `getPageNumber` works incorrectly for SbrkIndex. Sbrk index should be changed to MemoryIndex
-        const firstPageNumber = getPageNumber(currentSbrkIndex);
-        const pagesToAllocate = (newSbrkIndex - currentSbrkIndex) / PAGE_SIZE$1;
-        const rangeToAllocate = PageRange.fromStartAndLength(firstPageNumber, pagesToAllocate);
-        for (const pageNumber of rangeToAllocate) {
-            const page = new WriteablePage(pageNumber);
-            this.memory.set(pageNumber, page);
         }
-        this.virtualSbrkIndex = newVirtualSbrkIndex;
-        this.sbrkIndex = newSbrkIndex;
-        return currentVirtualSbrkIndex;
-    }
-    getPageDump(pageNumber) {
-        const page = this.memory.get(pageNumber);
-        return page?.getPageDump() ?? null;
     }
-    getDirtyPages() {
-        return this.memory.keys();
+    isBeginningOfBasicBlock(index) {
+        return this.basicBlocks.has(index);
     }
 }
-
-class MemoryBuilder {
-    initialMemory = new Map();
-    isFinalized = false;
-    ensureNotFinalized() {
-        if (this.isFinalized) {
-            throw new FinalizedBuilderModification();
-        }
-    }
-    ensureNoReservedMemoryUsage(range) {
-        if (range.overlapsWith(RESERVED_MEMORY_RANGE)) {
-            throw new ReservedMemoryFault();
-        }
-    }
-    /**
-     * Create entire readable pages to handle the `[start, end)` range.
-     *
-     * Note that both `start` and `end` must be multiple of the `PAGE_SIZE`, i.e.
-     * they need to be the start indices of the pages.
-     *
-     * The data passed will be placed at `start`, but might be shorter than the requested range,
-     * prepend it with zeros if you don't wish to have it at the beginning of the page.
-     */
-    setReadablePages(start, end, data = new Uint8Array()) {
-        this.ensureNotFinalized();
-        check `${start < end} end has to be bigger than start`;
-        check `${start % PAGE_SIZE$1 === 0} start needs to be a multiple of page size (${PAGE_SIZE$1})`;
-        check `${end % PAGE_SIZE$1 === 0} end needs to be a multiple of page size (${PAGE_SIZE$1})`;
-        check `${data.length <= end - start} the initial data is longer than address range`;
-        const length = end - start;
-        const range = MemoryRange.fromStartAndLength(start, length);
-        this.ensureNoReservedMemoryUsage(range);
-        const pages = Array.from(PageRange.fromMemoryRange(range));
-        const noOfPages = pages.length;
-        for (let i = 0; i < noOfPages; i++) {
-            const pageNumber = pages[i];
-            const dataChunk = data.subarray(i * PAGE_SIZE$1, (i + 1) * PAGE_SIZE$1);
-            const page = new ReadablePage(pageNumber, dataChunk);
-            this.initialMemory.set(pageNumber, page);
-        }
-        return this;
+
+const instructionGasMap = (() => {
+    const instructionGasMap = new Array(HIGHEST_INSTRUCTION_NUMBER + 1);
+    for (let i = 0; i < HIGHEST_INSTRUCTION_NUMBER + 1; i++) {
+        const gas = byteToOpCodeMap[i]?.gas;
+        instructionGasMap[i] = gas;
     }
+    return instructionGasMap;
+})();
+
+class InstructionResult {
+    nextPc = 0;
+    status = null;
     /**
-     * Create entire writeable pages to handle the `[start, end)` range.
+     * A numeric exit parameter of the PVM.
      *
-     * Note that both `start` and `end` must be multiple of the `PAGE_SIZE`, i.e.
-     * they need to be the start indices of the pages.
+     * In case of a `status === Result.FAULT` this will be the memory address
+     * that triggered the fault.
+     * In case of a `status === Result.HOST` this will be the host call index
+     * that should be invoked.
      *
-     * The data passed will be placed at `start`, but might be shorter than the requested range,
-     * prepend it with zeros if you don't wish to have it at the beginning of the page.
-     */
-    setWriteablePages(start, end, data = new Uint8Array()) {
-        this.ensureNotFinalized();
-        check `${start < end} end has to be bigger than start`;
-        check `${start % PAGE_SIZE$1 === 0} start needs to be a multiple of page size (${PAGE_SIZE$1})`;
-        check `${end % PAGE_SIZE$1 === 0} end needs to be a multiple of page size (${PAGE_SIZE$1})`;
-        check `${data.length <= end - start} the initial data is longer than address range`;
-        const length = end - start;
-        const range = MemoryRange.fromStartAndLength(start, length);
-        this.ensureNoReservedMemoryUsage(range);
-        const pages = Array.from(PageRange.fromMemoryRange(range));
-        const noOfPages = pages.length;
-        for (let i = 0; i < noOfPages; i++) {
-            const pageNumber = pages[i];
-            const dataChunk = data.subarray(i * PAGE_SIZE$1, (i + 1) * PAGE_SIZE$1);
-            const page = new WriteablePage(pageNumber, dataChunk);
-            this.initialMemory.set(pageNumber, page);
-        }
-        return this;
-    }
-    /**
-     * This function can be useful when page map and initial memory data are provided separatelly.
-     * You can use setWriteablePages/setReadablePages to create empty pages and then setData to fill them
+     * In any other circumstance the value should be `null`.
      */
-    setData(start, data) {
-        this.ensureNotFinalized();
-        const pageOffset = start % PAGE_SIZE$1;
-        const remainingSpaceOnPage = PAGE_SIZE$1 - pageOffset;
-        check `${data.length <= remainingSpaceOnPage} The data has to fit into a single page.`;
-        const length = data.length;
-        const range = MemoryRange.fromStartAndLength(start, length);
-        this.ensureNoReservedMemoryUsage(range);
-        const pageNumber = getPageNumber(start);
-        const page = this.initialMemory.get(pageNumber);
-        if (page === undefined) {
-            throw new PageNotExist();
-        }
-        const startPageIndex = tryAsPageIndex(start - page.start);
-        page.setData(startPageIndex, data);
-        return this;
-    }
-    finalize(startHeapIndex, endHeapIndex) {
-        check `
-      ${startHeapIndex <= endHeapIndex}
-      startHeapIndex (${startHeapIndex}) has to be less than or equal to endHeapIndex (${endHeapIndex})
-    `;
-        this.ensureNotFinalized();
-        const heapRange = MemoryRange.fromStartAndLength(startHeapIndex, endHeapIndex - startHeapIndex);
-        const heapPagesRange = PageRange.fromMemoryRange(heapRange);
-        const initializedPageNumbers = Array.from(this.initialMemory.keys());
-        for (const pageNumber of initializedPageNumbers) {
-            if (heapPagesRange.isInRange(pageNumber)) {
-                throw new IncorrectSbrkIndex();
-            }
-        }
-        const memory = Memory.fromInitialMemory({
-            memory: this.initialMemory,
-            sbrkIndex: tryAsSbrkIndex(startHeapIndex),
-            endHeapIndex,
-        });
-        this.isFinalized = true;
-        return memory;
+    exitParam = null;
+    reset() {
+        this.nextPc = 0;
+        this.status = null;
+        this.exitParam = null;
     }
 }
 
@@ -15490,7 +15935,7 @@ class StoreOps {
         }
         else {
             this.instructionResult.status = Result.FAULT;
-            this.instructionResult.exitParam = getStartPageIndex(storeResult.error.address);
+            this.instructionResult.exitParam = getStartPageIndex(tryAsMemoryIndex(storeResult.error.address));
         }
     }
 }
@@ -16142,7 +16587,7 @@ class JumpTable {
     }
 }
 
-const logger$2 = Logger.new(import.meta.filename, "pvm-interpreter");
+const logger$1 = Logger.new(import.meta.filename, "pvm-interpreter");
 var ProgramDecoderError;
 (function (ProgramDecoderError) {
     ProgramDecoderError[ProgramDecoderError["InvalidProgramError"] = 0] = "InvalidProgramError";
@@ -16192,21 +16637,21 @@ class ProgramDecoder {
             return Result$1.ok(new ProgramDecoder(program));
         }
         catch (e) {
-            logger$2.error `Invalid program: ${e}`;
+            logger$1.error `Invalid program: ${e}`;
             return Result$1.error(ProgramDecoderError.InvalidProgramError, () => `Program decoder error: ${e}`);
         }
     }
 }
 
-const logger$1 = Logger.new(import.meta.filename, "pvm");
+const logger = Logger.new(import.meta.filename, "pvm");
 class Interpreter {
     useSbrkGas;
     registers = new Registers();
+    memory = new Memory();
+    gas = gasCounter(tryAsGas(0));
     code = new Uint8Array();
     mask = Mask.empty();
     pc = 0;
-    gas = gasCounter(tryAsGas(0));
-    initialGas = gasCounter(tryAsGas(0));
     argsDecoder;
     threeRegsDispatcher;
     twoRegsOneImmDispatcher;
@@ -16216,7 +16661,6 @@ class Interpreter {
     oneOffsetDispatcher;
     oneRegOneImmDispatcher;
     instructionResult = new InstructionResult();
-    memory = new Memory();
     twoImmsDispatcher;
     oneRegTwoImmsDispatcher;
     noArgsDispatcher;
@@ -16258,14 +16702,17 @@ class Interpreter {
         this.oneImmDispatcher = new OneImmDispatcher(hostCallOps);
         this.oneRegOneExtImmDispatcher = new OneRegOneExtImmDispatcher(loadOps);
     }
-    reset(rawProgram, pc, gas, maybeRegisters, maybeMemory) {
+    resetJam(program, args, pc, gas) {
+        const p = Program.fromSpi(program, args, true);
+        this.resetGeneric(p.code, pc, gas, p.registers, p.memory);
+    }
+    resetGeneric(rawProgram, pc, gas, maybeRegisters, maybeMemory) {
         const programDecoder = new ProgramDecoder(rawProgram);
         this.code = programDecoder.getCode();
         this.mask = programDecoder.getMask();
         this.jumpTable.copyFrom(programDecoder.getJumpTable());
         this.pc = pc;
         this.gas = gasCounter(gas);
-        this.initialGas = gasCounter(gas);
         this.status = Status.OK;
         this.argsDecoder.reset(this.code, this.mask);
         this.basicBlocks.reset(this.code, this.mask);
@@ -16317,7 +16764,7 @@ class Interpreter {
         const argsType = instructionArgumentTypeMap[currentInstruction] ?? ArgumentType.NO_ARGUMENTS;
         const argsResult = this.argsDecodingResults[argsType];
         this.argsDecoder.fillArgs(this.pc, argsResult);
-        logger$1.insane `[PC: ${this.pc}] ${Instruction[currentInstruction]}`;
+        logger.insane `[PC: ${this.pc}] ${Instruction[currentInstruction]}`;
         if (!isValidInstruction) {
             this.instructionResult.status = Result.PANIC;
         }
@@ -16389,34 +16836,18 @@ class Interpreter {
                     this.status = Status.HOST;
                     break;
             }
-            logger$1.insane `[PC: ${this.pc}] Status: ${Result[this.instructionResult.status]}`;
+            logger.insane `[PC: ${this.pc}] Status: ${Result[this.instructionResult.status]}`;
             return this.status;
         }
         this.pc = this.instructionResult.nextPc;
         return this.status;
     }
-    getRegisters() {
-        return this.registers;
-    }
     getPC() {
         return this.pc;
     }
     setNextPC(nextPc) {
         this.pc = nextPc;
     }
-    getGas() {
-        return this.gas.get();
-    }
-    getGasConsumed() {
-        const gasConsumed = tryAsBigGas(this.initialGas.get()) - tryAsBigGas(this.gas.get());
-        if (gasConsumed < 0) {
-            return this.initialGas.get();
-        }
-        return tryAsBigGas(gasConsumed);
-    }
-    getGasCounter() {
-        return this.gas;
-    }
     getStatus() {
         return this.status;
     }
@@ -16424,9 +16855,6 @@ class Interpreter {
         const p = this.instructionResult.exitParam;
         return p !== null ? tryAsU32(p) : p;
     }
-    getMemory() {
-        return this.memory;
-    }
     getMemoryPage(pageNumber) {
         return this.memory.getPageDump(tryAsPageNumber(pageNumber));
     }
@@ -16450,212 +16878,560 @@ class Interpreter {
     }
 }
 
-var index$7 = /*#__PURE__*/Object.freeze({
+var index$5 = /*#__PURE__*/Object.freeze({
   __proto__: null,
   Interpreter: Interpreter,
   Memory: Memory,
   MemoryBuilder: MemoryBuilder,
   Registers: Registers,
   gasCounter: gasCounter,
-  tryAsBigGas: tryAsBigGas,
-  tryAsGas: tryAsGas,
   tryAsMemoryIndex: tryAsMemoryIndex,
-  tryAsSbrkIndex: tryAsSbrkIndex,
-  tryAsSmallGas: tryAsSmallGas
+  tryAsSbrkIndex: tryAsSbrkIndex
 });
 
-class HostCallMemory {
-    memory;
-    constructor(memory) {
-        this.memory = memory;
-    }
-    storeFrom(address, bytes) {
-        if (bytes.length === 0) {
-            return Result$1.ok(OK);
-        }
-        if (address + tryAsU64(bytes.length) > MEMORY_SIZE) {
-            return Result$1.error(new OutOfBounds(), () => `Memory access out of bounds: address ${address} + length ${bytes.length} exceeds memory size`);
-        }
-        return this.memory.storeFrom(tryAsMemoryIndex(Number(address)), bytes);
-    }
-    loadInto(result, startAddress) {
-        if (result.length === 0) {
-            return Result$1.ok(OK);
-        }
-        if (startAddress + tryAsU64(result.length) > MEMORY_SIZE) {
-            return Result$1.error(new OutOfBounds(), () => `Memory access out of bounds: address ${startAddress} + length ${result.length} exceeds memory size`);
-        }
-        return this.memory.loadInto(result, tryAsMemoryIndex(Number(startAddress)));
+async function instantiate(module, imports = {}) {
+  const adaptedImports = {
+    env: Object.setPrototypeOf({
+      abort(message, fileName, lineNumber, columnNumber) {
+        // ~lib/builtins/abort(~lib/string/String | null?, ~lib/string/String | null?, u32?, u32?) => void
+        message = __liftString(message >>> 0);
+        fileName = __liftString(fileName >>> 0);
+        lineNumber = lineNumber >>> 0;
+        columnNumber = columnNumber >>> 0;
+        (() => {
+          // @external.js
+          throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`);
+        })();
+      },
+      "console.log"(text) {
+        // ~lib/bindings/dom/console.log(~lib/string/String) => void
+        text = __liftString(text >>> 0);
+        console.log(text);
+      },
+    }, Object.assign(Object.create(globalThis), imports.env || {})),
+  };
+  const { exports } = await WebAssembly.instantiate(module, adaptedImports);
+  const memory = exports.memory || imports.env.memory;
+  const adaptedExports = Object.setPrototypeOf({
+    getAssembly(p) {
+      // assembly/api-internal/getAssembly(assembly/program/Program) => ~lib/string/String
+      p = __lowerInternref(p) || __notnull();
+      return __liftString(exports.getAssembly(p) >>> 0);
+    },
+    wrapAsProgram(bytecode) {
+      // assembly/program-build/wrapAsProgram(~lib/typedarray/Uint8Array) => ~lib/typedarray/Uint8Array
+      bytecode = __lowerTypedArray(Uint8Array, 10, 0, bytecode) || __notnull();
+      return __liftTypedArray(Uint8Array, exports.wrapAsProgram(bytecode) >>> 0);
+    },
+    resetJAM(program, pc, initialGas, args, hasMetadata) {
+      // assembly/api-debugger/resetJAM(~lib/array/Array<u8>, f64, i64, ~lib/array/Array<u8>, bool?) => void
+      program = __retain(__lowerArray(__setU8, 6, 0, program) || __notnull());
+      initialGas = initialGas || 0n;
+      args = __lowerArray(__setU8, 6, 0, args) || __notnull();
+      hasMetadata = hasMetadata ? 1 : 0;
+      try {
+        exports.__setArgumentsLength(arguments.length);
+        exports.resetJAM(program, pc, initialGas, args, hasMetadata);
+      } finally {
+        __release(program);
+      }
+    },
+    resetGeneric(program, flatRegisters, initialGas, hasMetadata) {
+      // assembly/api-debugger/resetGeneric(~lib/array/Array<u8>, ~lib/array/Array<u8>, i64, bool?) => void
+      program = __retain(__lowerArray(__setU8, 6, 0, program) || __notnull());
+      flatRegisters = __lowerArray(__setU8, 6, 0, flatRegisters) || __notnull();
+      initialGas = initialGas || 0n;
+      hasMetadata = hasMetadata ? 1 : 0;
+      try {
+        exports.__setArgumentsLength(arguments.length);
+        exports.resetGeneric(program, flatRegisters, initialGas, hasMetadata);
+      } finally {
+        __release(program);
+      }
+    },
+    resetGenericWithMemory(program, flatRegisters, pageMap, chunks, initialGas, hasMetadata) {
+      // assembly/api-debugger/resetGenericWithMemory(~lib/array/Array<u8>, ~lib/array/Array<u8>, ~lib/typedarray/Uint8Array, ~lib/typedarray/Uint8Array, i64, bool?) => void
+      program = __retain(__lowerArray(__setU8, 6, 0, program) || __notnull());
+      flatRegisters = __retain(__lowerArray(__setU8, 6, 0, flatRegisters) || __notnull());
+      pageMap = __retain(__lowerTypedArray(Uint8Array, 10, 0, pageMap) || __notnull());
+      chunks = __lowerTypedArray(Uint8Array, 10, 0, chunks) || __notnull();
+      initialGas = initialGas || 0n;
+      hasMetadata = hasMetadata ? 1 : 0;
+      try {
+        exports.__setArgumentsLength(arguments.length);
+        exports.resetGenericWithMemory(program, flatRegisters, pageMap, chunks, initialGas, hasMetadata);
+      } finally {
+        __release(program);
+        __release(flatRegisters);
+        __release(pageMap);
+      }
+    },
+    nextStep() {
+      // assembly/api-debugger/nextStep() => bool
+      return exports.nextStep() != 0;
+    },
+    nSteps(steps) {
+      // assembly/api-debugger/nSteps(u32) => bool
+      return exports.nSteps(steps) != 0;
+    },
+    getProgramCounter() {
+      // assembly/api-debugger/getProgramCounter() => u32
+      return exports.getProgramCounter() >>> 0;
+    },
+    getExitArg() {
+      // assembly/api-debugger/getExitArg() => u32
+      return exports.getExitArg() >>> 0;
+    },
+    setGasLeft(gas) {
+      // assembly/api-debugger/setGasLeft(i64) => void
+      gas = gas || 0n;
+      exports.setGasLeft(gas);
+    },
+    getRegisters() {
+      // assembly/api-debugger/getRegisters() => ~lib/typedarray/Uint8Array
+      return __liftTypedArray(Uint8Array, exports.getRegisters() >>> 0);
+    },
+    setRegisters(flatRegisters) {
+      // assembly/api-debugger/setRegisters(~lib/array/Array<u8>) => void
+      flatRegisters = __lowerArray(__setU8, 6, 0, flatRegisters) || __notnull();
+      exports.setRegisters(flatRegisters);
+    },
+    getPageDump(index) {
+      // assembly/api-debugger/getPageDump(u32) => ~lib/typedarray/Uint8Array
+      return __liftTypedArray(Uint8Array, exports.getPageDump(index) >>> 0);
+    },
+    getMemory(address, length) {
+      // assembly/api-debugger/getMemory(u32, u32) => ~lib/typedarray/Uint8Array | null
+      return __liftTypedArray(Uint8Array, exports.getMemory(address, length) >>> 0);
+    },
+    setMemory(address, data) {
+      // assembly/api-debugger/setMemory(u32, ~lib/typedarray/Uint8Array) => bool
+      data = __lowerTypedArray(Uint8Array, 10, 0, data) || __notnull();
+      return exports.setMemory(address, data) != 0;
+    },
+    InputKind: (values => (
+      // assembly/api-utils/InputKind
+      values[values.Generic = exports["InputKind.Generic"].valueOf()] = "Generic",
+      values[values.SPI = exports["InputKind.SPI"].valueOf()] = "SPI",
+      values
+    ))({}),
+    HasMetadata: (values => (
+      // assembly/api-utils/HasMetadata
+      values[values.Yes = exports["HasMetadata.Yes"].valueOf()] = "Yes",
+      values[values.No = exports["HasMetadata.No"].valueOf()] = "No",
+      values
+    ))({}),
+    getGasCosts(input, kind, withMetadata) {
+      // assembly/api-utils/getGasCosts(~lib/array/Array<u8>, i32, i32) => ~lib/array/Array<assembly/gas-costs/BlockGasCost>
+      input = __lowerArray(__setU8, 6, 0, input) || __notnull();
+      return __liftArray(pointer => __liftRecord50(__getU32(pointer)), 2, exports.getGasCosts(input, kind, withMetadata) >>> 0);
+    },
+    disassemble(input, kind, withMetadata) {
+      // assembly/api-utils/disassemble(~lib/array/Array<u8>, i32, i32) => ~lib/string/String
+      input = __lowerArray(__setU8, 6, 0, input) || __notnull();
+      return __liftString(exports.disassemble(input, kind, withMetadata) >>> 0);
+    },
+    prepareProgram(kind, hasMetadata, program, initialRegisters, initialPageMap, initialMemory, args) {
+      // assembly/api-utils/prepareProgram(i32, i32, ~lib/array/Array<u8>, ~lib/array/Array<u64>, ~lib/array/Array<assembly/api-internal/InitialPage>, ~lib/array/Array<assembly/api-internal/InitialChunk>, ~lib/array/Array<u8>) => assembly/spi/StandardProgram
+      program = __retain(__lowerArray(__setU8, 6, 0, program) || __notnull());
+      initialRegisters = __retain(__lowerArray(__setU64, 52, 3, initialRegisters) || __notnull());
+      initialPageMap = __retain(__lowerArray((pointer, value) => { __setU32(pointer, __lowerRecord46(value) || __notnull()); }, 47, 2, initialPageMap) || __notnull());
+      initialMemory = __retain(__lowerArray((pointer, value) => { __setU32(pointer, __lowerRecord48(value) || __notnull()); }, 49, 2, initialMemory) || __notnull());
+      args = __lowerArray(__setU8, 6, 0, args) || __notnull();
+      try {
+        return __liftInternref(exports.prepareProgram(kind, hasMetadata, program, initialRegisters, initialPageMap, initialMemory, args) >>> 0);
+      } finally {
+        __release(program);
+        __release(initialRegisters);
+        __release(initialPageMap);
+        __release(initialMemory);
+      }
+    },
+    runProgram(program, initialGas, programCounter, logs, useSbrkGas) {
+      // assembly/api-utils/runProgram(assembly/spi/StandardProgram, i64?, u32?, bool?, bool?) => assembly/api-internal/VmOutput
+      program = __lowerInternref(program) || __notnull();
+      initialGas = initialGas || 0n;
+      logs = logs ? 1 : 0;
+      useSbrkGas = useSbrkGas ? 1 : 0;
+      exports.__setArgumentsLength(arguments.length);
+      return __liftRecord55(exports.runProgram(program, initialGas, programCounter, logs, useSbrkGas) >>> 0);
+    },
+  }, exports);
+  function __liftRecord50(pointer) {
+    // assembly/gas-costs/BlockGasCost
+    // Hint: Opt-out from lifting as a record by providing an empty constructor
+    if (!pointer) return null;
+    return {
+      pc: __getU32(pointer + 0),
+      gas: __getU64(pointer + 8),
+    };
+  }
+  function __lowerRecord46(value) {
+    // assembly/api-internal/InitialPage
+    // Hint: Opt-out from lowering as a record by providing an empty constructor
+    if (value == null) return 0;
+    const pointer = exports.__pin(exports.__new(12, 46));
+    __setU32(pointer + 0, value.address);
+    __setU32(pointer + 4, value.length);
+    __setU32(pointer + 8, value.access);
+    exports.__unpin(pointer);
+    return pointer;
+  }
+  function __lowerRecord48(value) {
+    // assembly/api-internal/InitialChunk
+    // Hint: Opt-out from lowering as a record by providing an empty constructor
+    if (value == null) return 0;
+    const pointer = exports.__pin(exports.__new(8, 48));
+    __setU32(pointer + 0, value.address);
+    __setU32(pointer + 4, __lowerArray(__setU8, 6, 0, value.data) || __notnull());
+    exports.__unpin(pointer);
+    return pointer;
+  }
+  function __liftRecord48(pointer) {
+    // assembly/api-internal/InitialChunk
+    // Hint: Opt-out from lifting as a record by providing an empty constructor
+    if (!pointer) return null;
+    return {
+      address: __getU32(pointer + 0),
+      data: __liftArray(__getU8, 0, __getU32(pointer + 4)),
+    };
+  }
+  function __liftRecord55(pointer) {
+    // assembly/api-internal/VmOutput
+    // Hint: Opt-out from lifting as a record by providing an empty constructor
+    if (!pointer) return null;
+    return {
+      status: __getI32(pointer + 0),
+      registers: __liftArray(pointer => BigInt.asUintN(64, __getU64(pointer)), 3, __getU32(pointer + 4)),
+      pc: __getU32(pointer + 8),
+      memory: __liftArray(pointer => __liftRecord48(__getU32(pointer)), 2, __getU32(pointer + 12)),
+      gas: __getI64(pointer + 16),
+      exitCode: __getU32(pointer + 24),
+    };
+  }
+  function __liftString(pointer) {
+    if (!pointer) return null;
+    const
+      end = pointer + new Uint32Array(memory.buffer)[pointer - 4 >>> 2] >>> 1,
+      memoryU16 = new Uint16Array(memory.buffer);
+    let
+      start = pointer >>> 1,
+      string = "";
+    while (end - start > 1024) string += String.fromCharCode(...memoryU16.subarray(start, start += 1024));
+    return string + String.fromCharCode(...memoryU16.subarray(start, end));
+  }
+  function __liftArray(liftElement, align, pointer) {
+    if (!pointer) return null;
+    const
+      dataStart = __getU32(pointer + 4),
+      length = __dataview.getUint32(pointer + 12, true),
+      values = new Array(length);
+    for (let i = 0; i < length; ++i) values[i] = liftElement(dataStart + (i << align >>> 0));
+    return values;
+  }
+  function __lowerArray(lowerElement, id, align, values) {
+    if (values == null) return 0;
+    const
+      length = values.length,
+      buffer = exports.__pin(exports.__new(length << align, 1)) >>> 0,
+      header = exports.__pin(exports.__new(16, id)) >>> 0;
+    __setU32(header + 0, buffer);
+    __dataview.setUint32(header + 4, buffer, true);
+    __dataview.setUint32(header + 8, length << align, true);
+    __dataview.setUint32(header + 12, length, true);
+    for (let i = 0; i < length; ++i) lowerElement(buffer + (i << align >>> 0), values[i]);
+    exports.__unpin(buffer);
+    exports.__unpin(header);
+    return header;
+  }
+  function __liftTypedArray(constructor, pointer) {
+    if (!pointer) return null;
+    return new constructor(
+      memory.buffer,
+      __getU32(pointer + 4),
+      __dataview.getUint32(pointer + 8, true) / constructor.BYTES_PER_ELEMENT
+    ).slice();
+  }
+  function __lowerTypedArray(constructor, id, align, values) {
+    if (values == null) return 0;
+    const
+      length = values.length,
+      buffer = exports.__pin(exports.__new(length << align, 1)) >>> 0,
+      header = exports.__new(12, id) >>> 0;
+    __setU32(header + 0, buffer);
+    __dataview.setUint32(header + 4, buffer, true);
+    __dataview.setUint32(header + 8, length << align, true);
+    new constructor(memory.buffer, buffer, length).set(values);
+    exports.__unpin(buffer);
+    return header;
+  }
+  class Internref extends Number {}
+  const registry = new FinalizationRegistry(__release);
+  function __liftInternref(pointer) {
+    if (!pointer) return null;
+    const sentinel = new Internref(__retain(pointer));
+    registry.register(sentinel, pointer);
+    return sentinel;
+  }
+  function __lowerInternref(value) {
+    if (value == null) return 0;
+    if (value instanceof Internref) return value.valueOf();
+    throw TypeError("internref expected");
+  }
+  const refcounts = new Map();
+  function __retain(pointer) {
+    if (pointer) {
+      const refcount = refcounts.get(pointer);
+      if (refcount) refcounts.set(pointer, refcount + 1);
+      else refcounts.set(exports.__pin(pointer), 1);
+    }
+    return pointer;
+  }
+  function __release(pointer) {
+    if (pointer) {
+      const refcount = refcounts.get(pointer);
+      if (refcount === 1) exports.__unpin(pointer), refcounts.delete(pointer);
+      else if (refcount) refcounts.set(pointer, refcount - 1);
+      else throw Error(`invalid refcount '${refcount}' for reference '${pointer}'`);
+    }
+  }
+  function __notnull() {
+    throw TypeError("value must not be null");
+  }
+  let __dataview = new DataView(memory.buffer);
+  function __setU8(pointer, value) {
+    try {
+      __dataview.setUint8(pointer, value, true);
+    } catch {
+      __dataview = new DataView(memory.buffer);
+      __dataview.setUint8(pointer, value, true);
     }
-}
-
-class HostCallRegisters {
-    registers;
-    constructor(registers) {
-        this.registers = registers;
+  }
+  function __setU32(pointer, value) {
+    try {
+      __dataview.setUint32(pointer, value, true);
+    } catch {
+      __dataview = new DataView(memory.buffer);
+      __dataview.setUint32(pointer, value, true);
     }
-    get(registerIndex) {
-        return tryAsU64(this.registers.getU64(registerIndex));
+  }
+  function __setU64(pointer, value) {
+    try {
+      __dataview.setBigUint64(pointer, value, true);
+    } catch {
+      __dataview = new DataView(memory.buffer);
+      __dataview.setBigUint64(pointer, value, true);
     }
-    set(registerIndex, value) {
-        this.registers.setU64(registerIndex, value);
+  }
+  function __getU8(pointer) {
+    try {
+      return __dataview.getUint8(pointer, true);
+    } catch {
+      __dataview = new DataView(memory.buffer);
+      return __dataview.getUint8(pointer, true);
     }
-}
-
-class ReturnValue {
-    consumedGas;
-    status;
-    memorySlice;
-    constructor(consumedGas, status, memorySlice) {
-        this.consumedGas = consumedGas;
-        this.status = status;
-        this.memorySlice = memorySlice;
-        check `
-      ${(status === null && memorySlice !== null) || (status !== null && memorySlice === null)}
-      'status' and 'memorySlice' must not both be null or both be non-null — exactly one must be provided
-    `;
+  }
+  function __getI32(pointer) {
+    try {
+      return __dataview.getInt32(pointer, true);
+    } catch {
+      __dataview = new DataView(memory.buffer);
+      return __dataview.getInt32(pointer, true);
     }
-    static fromStatus(consumedGas, status) {
-        return new ReturnValue(consumedGas, status, null);
+  }
+  function __getU32(pointer) {
+    try {
+      return __dataview.getUint32(pointer, true);
+    } catch {
+      __dataview = new DataView(memory.buffer);
+      return __dataview.getUint32(pointer, true);
     }
-    static fromMemorySlice(consumedGas, memorySlice) {
-        return new ReturnValue(consumedGas, null, memorySlice);
+  }
+  function __getI64(pointer) {
+    try {
+      return __dataview.getBigInt64(pointer, true);
+    } catch {
+      __dataview = new DataView(memory.buffer);
+      return __dataview.getBigInt64(pointer, true);
     }
-    hasMemorySlice() {
-        return this.memorySlice instanceof Uint8Array && this.status === null;
+  }
+  function __getU64(pointer) {
+    try {
+      return __dataview.getBigUint64(pointer, true);
+    } catch {
+      __dataview = new DataView(memory.buffer);
+      return __dataview.getBigUint64(pointer, true);
+    }
+  }
+  return adaptedExports;
+}
+
+// TODO [ToDr] Temporary solution. We need to inline WASM files for the final build.
+const wasmPath = fileURLToPath(new URL(import.meta.resolve("@fluffylabs/anan-as/release-mini.wasm"), import.meta.url));
+const wasmBuffer = readFileSync(wasmPath);
+// Max u32 value
+const INF_STEPS = 2 ** 32 - 1;
+class AnanasRegisters {
+    instance;
+    constructor(instance) {
+        this.instance = instance;
+    }
+    getAllEncoded() {
+        return this.instance.getRegisters();
+    }
+    setAllEncoded(bytes) {
+        check `${bytes.length === NO_OF_REGISTERS$1 * REGISTER_BYTE_SIZE}
+          Incorrect size of input registers. Got: ${bytes.length},
+          need: ${NO_OF_REGISTERS$1 * REGISTER_BYTE_SIZE}`;
+        this.instance.setRegisters(lowerBytes(bytes));
     }
-    hasStatus() {
-        return !this.hasMemorySlice();
+    getAllU64() {
+        const bytes = this.getAllEncoded();
+        return new BigUint64Array(bytes.buffer, bytes.byteOffset);
     }
 }
-class HostCalls {
-    pvmInstanceManager;
-    hostCalls;
-    constructor(pvmInstanceManager, hostCalls) {
-        this.pvmInstanceManager = pvmInstanceManager;
-        this.hostCalls = hostCalls;
+class AnanasMemory {
+    instance;
+    constructor(instance) {
+        this.instance = instance;
     }
-    getReturnValue(status, pvmInstance) {
-        const gasConsumed = pvmInstance.getGasConsumed();
-        if (status === Status.OOG) {
-            return ReturnValue.fromStatus(gasConsumed, status);
-        }
-        if (status === Status.HALT) {
-            const memory = pvmInstance.getMemory();
-            const regs = pvmInstance.getRegisters();
-            const maybeAddress = regs.getLowerU32(7);
-            const maybeLength = regs.getLowerU32(8);
-            const result = safeAllocUint8Array(maybeLength);
-            const startAddress = tryAsMemoryIndex(maybeAddress);
-            const loadResult = memory.loadInto(result, startAddress);
-            if (loadResult.isError) {
-                return ReturnValue.fromMemorySlice(gasConsumed, new Uint8Array());
-            }
-            return ReturnValue.fromMemorySlice(gasConsumed, result);
+    store(address, bytes) {
+        if (this.instance.setMemory(address, bytes)) {
+            return Result$1.ok(OK);
         }
-        return ReturnValue.fromStatus(gasConsumed, Status.PANIC);
+        return Result$1.error({ address: getPageStartAddress(address) }, () => "Memory is unwritable!");
     }
-    async execute(pvmInstance) {
-        pvmInstance.runProgram();
-        for (;;) {
-            let status = pvmInstance.getStatus();
-            if (status !== Status.HOST) {
-                return this.getReturnValue(status, pvmInstance);
-            }
-            check `
-        ${pvmInstance.getExitParam() !== null}
-        "We know that the exit param is not null, because the status is 'Status.HOST'
-      `;
-            const hostCallIndex = pvmInstance.getExitParam() ?? -1;
-            const gas = pvmInstance.getGasCounter();
-            const regs = new HostCallRegisters(pvmInstance.getRegisters());
-            const memory = new HostCallMemory(pvmInstance.getMemory());
-            const index = tryAsHostCallIndex(hostCallIndex);
-            const hostCall = this.hostCalls.get(index);
-            const gasBefore = gas.get();
-            // NOTE: `basicGasCost(regs)` function is for compatibility reasons: pre GP 0.7.2
-            const basicGasCost = typeof hostCall.basicGasCost === "number" ? hostCall.basicGasCost : hostCall.basicGasCost(regs);
-            const underflow = gas.sub(basicGasCost);
-            const pcLog = `[PC: ${pvmInstance.getPC()}]`;
-            if (underflow) {
-                this.hostCalls.traceHostCall(`${pcLog} OOG`, index, hostCall, regs, gas.get());
-                return ReturnValue.fromStatus(pvmInstance.getGasConsumed(), Status.OOG);
-            }
-            this.hostCalls.traceHostCall(`${pcLog} Invoking`, index, hostCall, regs, gasBefore);
-            const result = await hostCall.execute(gas, regs, memory);
-            this.hostCalls.traceHostCall(result === undefined ? `${pcLog} Result` : `${pcLog} Status(${PvmExecution[result]})`, index, hostCall, regs, gas.get());
-            if (result === PvmExecution.Halt) {
-                status = Status.HALT;
-                return this.getReturnValue(status, pvmInstance);
-            }
-            if (result === PvmExecution.Panic) {
-                status = Status.PANIC;
-                return this.getReturnValue(status, pvmInstance);
-            }
-            if (result === PvmExecution.OOG) {
-                status = Status.OOG;
-                return this.getReturnValue(status, pvmInstance);
-            }
-            if (result === undefined) {
-                pvmInstance.runProgram();
-                status = pvmInstance.getStatus();
-                continue;
-            }
-            assertNever(result);
+    read(address, result) {
+        if (result.length === 0) {
+            return Result$1.ok(OK);
         }
+        const newResult = this.instance.getMemory(address, result.length);
+        if (newResult === null) {
+            return Result$1.error({ address: getPageStartAddress(address) }, () => "Memory is inaccessible!");
+        }
+        result.set(newResult, 0);
+        return Result$1.ok(OK);
     }
-    async runProgram(rawProgram, initialPc, initialGas, maybeRegisters, maybeMemory) {
-        const pvmInstance = await this.pvmInstanceManager.getInstance();
-        pvmInstance.reset(rawProgram, initialPc, initialGas, maybeRegisters, maybeMemory);
-        try {
-            return await this.execute(pvmInstance);
+}
+class AnanasGasCounter {
+    instance;
+    initialGas = tryAsGas(0n);
+    constructor(instance) {
+        this.instance = instance;
+    }
+    get() {
+        return tryAsGas(this.instance.getGasLeft());
+    }
+    set(g) {
+        this.instance.setGasLeft(BigInt(g));
+    }
+    sub(g) {
+        const result = this.instance.getGasLeft() - BigInt(g);
+        if (result >= 0n) {
+            this.instance.setGasLeft(result);
+            return false;
         }
-        finally {
-            this.pvmInstanceManager.releaseInstance(pvmInstance);
+        this.instance.setGasLeft(0n);
+        return true;
+    }
+    used() {
+        const gasConsumed = BigInt(this.initialGas) - BigInt(this.get());
+        if (gasConsumed < 0) {
+            return this.initialGas;
         }
+        return tryAsBigGas(gasConsumed);
     }
 }
-
-const logger = Logger.new(import.meta.filename, "host-calls-pvm");
-/** Container for all available host calls. */
-class HostCallsManager {
-    hostCalls = new Map();
-    missing;
-    constructor({ missing, handlers = [], }) {
-        this.missing = missing;
-        for (const handler of handlers) {
-            check `${this.hostCalls.get(handler.index) === undefined} Overwriting host call handler at index ${handler.index}`;
-            this.hostCalls.set(handler.index, handler);
+class AnanasInterpreter {
+    instance;
+    registers;
+    memory;
+    gas;
+    constructor(instance) {
+        this.instance = instance;
+        this.registers = new AnanasRegisters(instance);
+        this.memory = new AnanasMemory(instance);
+        this.gas = new AnanasGasCounter(instance);
+    }
+    static async new() {
+        const wasmModule = await WebAssembly.compile(wasmBuffer);
+        const instance = await instantiate(wasmModule, {
+            env: {
+                abort: () => {
+                    throw new Error("Abort called from WASM");
+                },
+            },
+        });
+        return new AnanasInterpreter(instance);
+    }
+    resetJam(program, args, pc, gas) {
+        const programArr = lowerBytes(program);
+        const argsArr = lowerBytes(args);
+        this.gas.initialGas = gas;
+        this.instance.resetJAM(programArr, pc, BigInt(gas), argsArr, true);
+    }
+    resetGeneric(program, _pc, gas) {
+        const programArr = lowerBytes(program);
+        const emptyRegisters = Array(13 * 8).fill(0);
+        const pageMap = new Uint8Array();
+        const chunks = new Uint8Array();
+        this.gas.initialGas = gas;
+        this.instance.resetGenericWithMemory(programArr, emptyRegisters, pageMap, chunks, BigInt(gas), false);
+    }
+    nextStep() {
+        return this.instance.nextStep();
+    }
+    runProgram() {
+        // NOTE Setting max value u32 in nNextSteps making ananas running until finished
+        // without comming back and forth between JS <-> WASM
+        while (this.instance.nSteps(INF_STEPS)) { }
+    }
+    getStatus() {
+        const status = this.instance.getStatus();
+        if (status < 0) {
+            return Status.OK;
         }
+        check `${Status[status] !== undefined} Invalid status returned: ${status}`;
+        return status;
     }
-    /** Get a host call by index. */
-    get(hostCallIndex) {
-        return this.hostCalls.get(hostCallIndex) ?? this.missing;
+    getPC() {
+        return this.instance.getProgramCounter();
     }
-    traceHostCall(context, hostCallIndex, hostCallHandler, registers, gas) {
-        const { currentServiceId } = hostCallHandler;
-        const requested = hostCallIndex !== hostCallHandler.index ? ` (${hostCallIndex})` : "";
-        const name = `${hostCallHandler.constructor.name}:${hostCallHandler.index}`;
-        const registerValues = hostCallHandler.tracedRegisters
-            .map((idx) => [idx.toString().padStart(2, "0"), registers.get(idx)])
-            .filter((v) => v[1] !== 0n)
-            .map(([idx, value]) => {
-            return `r${idx}=${value} (0x${value.toString(16)})`;
-        })
-            .join(", ");
-        logger.insane `[${currentServiceId}] ${context} ${name}${requested}.  Gas: ${gas}. Regs: ${registerValues}.`;
+    getExitParam() {
+        return tryAsU32(this.instance.getExitArg());
+    }
+}
+/**  Convert `Uint8Array` to `number[]` */
+function lowerBytes(data) {
+    const r = new Array(data.length);
+    for (let i = 0; i < data.length; i++) {
+        r[i] = data[i];
     }
+    return r;
 }
 
+// TODO [MaSo] Delete this & also make host calls independent from intepreters.
 class InterpreterInstanceManager {
-    instances = [];
+    instances;
     waitingQueue = [];
-    constructor(noOfPvmInstances) {
-        for (let i = 0; i < noOfPvmInstances; i++) {
-            this.instances.push(new Interpreter({
-                useSbrkGas: false,
-            }));
+    constructor(instances) {
+        this.instances = instances;
+    }
+    static async new(interpreter) {
+        const instances = [];
+        switch (interpreter) {
+            case PvmBackend.BuiltIn:
+                instances.push(new Interpreter({
+                    useSbrkGas: false,
+                }));
+                break;
+            case PvmBackend.Ananas:
+                instances.push(await AnanasInterpreter.new());
+                break;
+            default:
+                assertNever(interpreter);
         }
+        return new InterpreterInstanceManager(instances);
     }
     async getInstance() {
         const instance = this.instances.pop();
@@ -16675,7 +17451,7 @@ class InterpreterInstanceManager {
     }
 }
 
-var index$6 = /*#__PURE__*/Object.freeze({
+var index$4 = /*#__PURE__*/Object.freeze({
   __proto__: null,
   HostCallMemory: HostCallMemory,
   HostCallRegisters: HostCallRegisters,
@@ -16687,194 +17463,6 @@ var index$6 = /*#__PURE__*/Object.freeze({
   tryAsHostCallIndex: tryAsHostCallIndex
 });
 
-// GP reference: https://graypaper.fluffylabs.dev/#/7e6ff6a/2d32002d3200?v=0.6.7
-const PAGE_SIZE = 2 ** 12; // Z_P from GP
-const SEGMENT_SIZE = 2 ** 16; // Z_Z from GP
-const DATA_LEGNTH = 2 ** 24; // Z_I from GP
-const STACK_SEGMENT = 0xfe_fe_00_00; // 2^32 - 2Z_Z - Z_I from GP
-const ARGS_SEGMENT = 0xfe_ff_00_00; // 2^32 - Z_Z - Z_I from GP
-const LAST_PAGE = 0xff_ff_00_00;
-
-// GP reference: https://graypaper.fluffylabs.dev/#/579bd12/2bd2022bd202
-function alignToSegmentSize(size) {
-    // Q(x) from GP
-    return SEGMENT_SIZE * Math.ceil(size / SEGMENT_SIZE);
-}
-function alignToPageSize(size) {
-    // P(x) from GP
-    return PAGE_SIZE * Math.ceil(size / PAGE_SIZE);
-}
-
-const NO_OF_REGISTERS = 13;
-class MemorySegment extends WithDebug {
-    start;
-    end;
-    data;
-    static from({ start, end, data }) {
-        return new MemorySegment(start, end, data);
-    }
-    constructor(start, end, data) {
-        super();
-        this.start = start;
-        this.end = end;
-        this.data = data;
-    }
-}
-class SpiMemory extends WithDebug {
-    readable;
-    writeable;
-    sbrkIndex;
-    heapEnd;
-    constructor(readable, writeable, sbrkIndex, heapEnd) {
-        super();
-        this.readable = readable;
-        this.writeable = writeable;
-        this.sbrkIndex = sbrkIndex;
-        this.heapEnd = heapEnd;
-    }
-}
-class SpiProgram extends WithDebug {
-    code;
-    memory;
-    registers;
-    constructor(code, memory, registers) {
-        super();
-        this.code = code;
-        this.memory = memory;
-        this.registers = registers;
-    }
-}
-/**
- * program = E_3(|o|) ++ E_3(|w|) ++ E_2(z) ++ E_3(s) ++ o ++ w ++ E_4(|c|) ++ c
- *
- * E_n - little endian encoding, n - length
- * o - initial read only data
- * w - initial heap
- * z - heap pages filled with zeros
- * s - stack size
- * c - program code
- *
- * https://graypaper.fluffylabs.dev/#/579bd12/2b92022b9202
- */
-function decodeStandardProgram(program, args) {
-    const decoder = Decoder.fromBlob(program);
-    const oLength = decoder.u24();
-    const wLength = decoder.u24();
-    check `${args.length <= DATA_LEGNTH} Incorrect arguments length`;
-    check `${oLength <= DATA_LEGNTH} Incorrect readonly segment length`;
-    const readOnlyLength = oLength;
-    check `${wLength <= DATA_LEGNTH} Incorrect heap segment length`;
-    const heapLength = wLength;
-    const noOfHeapZerosPages = decoder.u16();
-    const stackSize = decoder.u24();
-    const readOnlyMemory = decoder.bytes(readOnlyLength).raw;
-    const initialHeap = decoder.bytes(heapLength).raw;
-    const codeLength = decoder.u32();
-    const code = decoder.bytes(codeLength).raw;
-    decoder.finish();
-    const readonlyDataStart = SEGMENT_SIZE;
-    const readonlyDataEnd = SEGMENT_SIZE + alignToPageSize(readOnlyLength);
-    const heapDataStart = 2 * SEGMENT_SIZE + alignToSegmentSize(readOnlyLength);
-    const heapDataEnd = heapDataStart + alignToPageSize(heapLength);
-    const heapZerosEnd = heapDataStart + alignToPageSize(heapLength) + noOfHeapZerosPages * PAGE_SIZE;
-    const stackStart = STACK_SEGMENT - alignToPageSize(stackSize);
-    const stackEnd = STACK_SEGMENT;
-    const argsStart = ARGS_SEGMENT;
-    const argsEnd = argsStart + alignToPageSize(args.length);
-    const argsZerosEnd = argsEnd + alignToPageSize(args.length);
-    function nonEmpty(s) {
-        return s !== false;
-    }
-    const readableMemory = [
-        readOnlyLength > 0 && getMemorySegment(readonlyDataStart, readonlyDataEnd, readOnlyMemory),
-        args.length > 0 && getMemorySegment(argsStart, argsEnd, args),
-        argsEnd < argsZerosEnd && getMemorySegment(argsEnd, argsZerosEnd),
-    ].filter(nonEmpty);
-    const writeableMemory = [
-        heapLength > 0 && getMemorySegment(heapDataStart, heapDataEnd, initialHeap),
-        heapDataEnd < heapZerosEnd && getMemorySegment(heapDataEnd, heapZerosEnd),
-        stackStart < stackEnd && getMemorySegment(stackStart, stackEnd),
-    ].filter(nonEmpty);
-    return new SpiProgram(code, new SpiMemory(readableMemory, writeableMemory, heapZerosEnd, stackStart), getRegisters(args.length));
-}
-function getMemorySegment(start, end, data = null) {
-    return new MemorySegment(start, end, data);
-}
-function getRegisters(argsLength) {
-    const regs = new BigUint64Array(NO_OF_REGISTERS);
-    // GP reference: https://graypaper.fluffylabs.dev/#/579bd12/2c7c012cb101
-    regs[0] = BigInt(LAST_PAGE);
-    regs[1] = BigInt(STACK_SEGMENT);
-    regs[7] = BigInt(ARGS_SEGMENT);
-    regs[8] = BigInt(argsLength);
-    return regs;
-}
-
-var index$5 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  MemorySegment: MemorySegment,
-  SpiMemory: SpiMemory,
-  SpiProgram: SpiProgram,
-  decodeStandardProgram: decodeStandardProgram
-});
-
-class Program {
-    code;
-    registers;
-    memory;
-    metadata;
-    static fromSpi(blob, args, hasMetadata) {
-        const { code: spiCode, metadata } = hasMetadata ? extractCodeAndMetadata(blob) : { code: blob };
-        const { code, memory: rawMemory, registers } = decodeStandardProgram(spiCode, args);
-        const regs = new Registers();
-        regs.copyFrom(registers);
-        const memoryBuilder = new MemoryBuilder();
-        for (const { start, end, data } of rawMemory.readable) {
-            const startIndex = tryAsMemoryIndex(start);
-            const endIndex = tryAsMemoryIndex(end);
-            memoryBuilder.setReadablePages(startIndex, endIndex, data ?? new Uint8Array());
-        }
-        for (const { start, end, data } of rawMemory.writeable) {
-            const startIndex = tryAsMemoryIndex(start);
-            const endIndex = tryAsMemoryIndex(end);
-            memoryBuilder.setWriteablePages(startIndex, endIndex, data ?? new Uint8Array());
-        }
-        const heapStart = tryAsMemoryIndex(rawMemory.sbrkIndex);
-        const heapEnd = tryAsSbrkIndex(rawMemory.heapEnd);
-        const memory = memoryBuilder.finalize(heapStart, heapEnd);
-        return new Program(code, regs, memory, metadata);
-    }
-    static fromGeneric(blob, hasMetadata) {
-        const { code, metadata } = hasMetadata ? extractCodeAndMetadata(blob) : { code: blob };
-        const regs = new Registers();
-        const memory = new Memory();
-        return new Program(code, regs, memory, metadata);
-    }
-    constructor(code, registers, memory, metadata = new Uint8Array()) {
-        this.code = code;
-        this.registers = registers;
-        this.memory = memory;
-        this.metadata = metadata;
-    }
-}
-/**
- * A function that splits preimage into metadata and code.
- *
- * https://graypaper.fluffylabs.dev/#/cc517d7/109a01109a01?v=0.6.5
- */
-function extractCodeAndMetadata(blobWithMetadata) {
-    const decoder = Decoder.fromBlob(blobWithMetadata);
-    const metadata = decoder.bytesBlob().raw;
-    const code = decoder.remainingBytes().raw;
-    return { metadata, code };
-}
-
-var index$4 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  Program: Program,
-  extractCodeAndMetadata: extractCodeAndMetadata
-});
-
 class DebuggerAdapter {
     pvm;
     constructor(useSbrkGas = false) {
@@ -16885,10 +17473,10 @@ class DebuggerAdapter {
         return this.pvm;
     }
     resetGeneric(rawProgram, flatRegisters, initialGas) {
-        this.pvm.reset(rawProgram, 0, tryAsGas(initialGas), new Registers(flatRegisters));
+        this.pvm.resetGeneric(rawProgram, 0, tryAsGas(initialGas), new Registers(flatRegisters));
     }
     reset(rawProgram, pc, gas, maybeRegisters, maybeMemory) {
-        this.pvm.reset(rawProgram, pc, tryAsGas(gas), maybeRegisters, maybeMemory);
+        this.pvm.resetGeneric(rawProgram, pc, tryAsGas(gas), maybeRegisters, maybeMemory);
     }
     getPageDump(pageNumber) {
         const page = this.pvm.getMemoryPage(pageNumber);
@@ -16906,7 +17494,7 @@ class DebuggerAdapter {
         return fullPage;
     }
     setMemory(address, value) {
-        this.pvm.getMemory().storeFrom(tryAsMemoryIndex(address), value);
+        this.pvm.memory.storeFrom(tryAsMemoryIndex(address), value);
     }
     getExitArg() {
         return this.pvm.getExitParam() ?? 0;
@@ -16928,10 +17516,10 @@ class DebuggerAdapter {
         return true;
     }
     getRegisters() {
-        return this.pvm.getRegisters().getAllU64();
+        return this.pvm.registers.getAllU64();
     }
     setRegisters(registers) {
-        this.pvm.getRegisters().copyFrom(new Registers(registers));
+        this.pvm.registers.copyFrom(new Registers(registers));
     }
     getProgramCounter() {
         return this.pvm.getPC();
@@ -16940,10 +17528,10 @@ class DebuggerAdapter {
         this.pvm.setNextPC(nextPc);
     }
     getGasLeft() {
-        return BigInt(this.pvm.getGas());
+        return BigInt(this.pvm.gas.get());
     }
     setGasLeft(gas) {
-        this.pvm.getGasCounter().set(tryAsGas(gas));
+        this.pvm.gas.set(tryAsGas(gas));
     }
 }
 
@@ -17002,13 +17590,14 @@ var index$3 = /*#__PURE__*/Object.freeze({
   clampU64ToU32: clampU64ToU32,
   createResults: createResults,
   decodeStandardProgram: decodeStandardProgram,
+  emptyRegistersBuffer: emptyRegistersBuffer,
   extractCodeAndMetadata: extractCodeAndMetadata,
   getServiceId: getServiceId,
   getServiceIdOrCurrent: getServiceIdOrCurrent,
   hash: index$o,
   inspect: inspect,
   instructionArgumentTypeMap: instructionArgumentTypeMap,
-  interpreter: index$7,
+  interpreter: index$5,
   isBrowser: isBrowser,
   measure: measure,
   numbers: index$r,
@@ -17615,4 +18204,4 @@ var index = /*#__PURE__*/Object.freeze({
   TransitionHasher: TransitionHasher
 });
 
-export { index$l as block, index$j as block_json, index$s as bytes, index$q as codec, index$n as collections, index$m as config, index$h as config_node, index$p as crypto, index$d as database, index$c as erasure_coding, index$a as fuzz_proto, index$o as hash, index$9 as jam_host_calls, index$k as json_parser, index$i as logger, index$8 as mmr, index$r as numbers, index$t as ordering, index$3 as pvm, index$6 as pvm_host_calls, index$7 as pvm_interpreter, index$4 as pvm_program, index$5 as pvm_spi_decoder, index$2 as shuffling, index$g as state, index$1 as state_json, index$e as state_merkleization, index as transition, index$f as trie, index$u as utils };
+export { index$l as block, index$j as block_json, index$s as bytes, index$q as codec, index$n as collections, index$m as config, index$h as config_node, index$p as crypto, index$d as database, index$c as erasure_coding, index$a as fuzz_proto, index$o as hash, index$9 as jam_host_calls, index$k as json_parser, index$i as logger, index$8 as mmr, index$r as numbers, index$t as ordering, index$3 as pvm, index$4 as pvm_host_calls, index$5 as pvm_interpreter, index$6 as pvm_program, index$7 as pvm_spi_decoder, index$2 as shuffling, index$g as state, index$1 as state_json, index$e as state_merkleization, index as transition, index$f as trie, index$u as utils };