@typeberry/convert 0.4.1-818bae8 → 0.4.1-8a21145

package/index.js

@@ -4339,6 +4339,15 @@ class Compatibility {
 function isBrowser() {
     return typeof process === "undefined" || typeof process.abort === "undefined";
 }
+/**
+ * Get current time in milliseconds (works in both Node and browser).
+ *
+ * Node.js implementation converts hrtime bigint nanoseconds to milliseconds.
+ * This is safe because dividing nanoseconds by 1_000_000 yields milliseconds,
+ * which remain well below Number.MAX_SAFE_INTEGER for practical runtimes
+ * (would take ~285 years to overflow).
+ */
+const now = isBrowser() ? () => performance.now() : () => Number(process.hrtime.bigint() / 1000000n);
 /**
  * A function to perform runtime assertions.
  *
@@ -4427,19 +4436,10 @@ function debug_inspect(val) {
     return v;
 }
 /** Utility function to measure time taken for some operation [ms]. */
-const measure = isBrowser()
-    ? (id) => {
-        const start = performance.now();
-        return () => `${id} took ${performance.now() - start}ms`;
-    }
-    : (id) => {
-        const start = process.hrtime.bigint();
-        return () => {
-            const tookNano = process.hrtime.bigint() - start;
-            const tookMilli = Number(tookNano / 1000000n).toFixed(2);
-            return `${id} took ${tookMilli}ms`;
-        };
-    };
+function measure(id) {
+    const start = now();
+    return () => `${id} took ${(now() - start).toFixed(2)}ms`;
+}
 /** A class that adds `toString` method that prints all properties of an object. */
 class WithDebug {
     toString() {
@@ -4843,6 +4843,7 @@ function isResult(x) {
 
 
 
+
 // EXTERNAL MODULE: ./node_modules/minimist/index.js
 var minimist = __nccwpck_require__(595);
 var minimist_default = /*#__PURE__*/__nccwpck_require__.n(minimist);
@@ -11869,7 +11870,7 @@ class FuzzTarget {
 
 
 
-;// CONCATENATED MODULE: ./packages/core/pvm-spi-decoder/memory-conts.ts
+;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/spi-decoder/memory-conts.ts
 // GP reference: https://graypaper.fluffylabs.dev/#/7e6ff6a/2d32002d3200?v=0.6.7
 const memory_conts_PAGE_SIZE = 2 ** 12; // Z_P from GP
 const SEGMENT_SIZE = 2 ** 16; // Z_Z from GP
@@ -11878,7 +11879,7 @@ 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;
 
-;// CONCATENATED MODULE: ./packages/core/pvm-spi-decoder/memory-utils.ts
+;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/spi-decoder/memory-utils.ts
 
 // GP reference: https://graypaper.fluffylabs.dev/#/579bd12/2bd2022bd202
 function alignToSegmentSize(size) {
@@ -11890,7 +11891,7 @@ function memory_utils_alignToPageSize(size) {
     return memory_conts_PAGE_SIZE * Math.ceil(size / memory_conts_PAGE_SIZE);
 }
 
-;// CONCATENATED MODULE: ./packages/core/pvm-spi-decoder/decode-standard-program.ts
+;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/spi-decoder/decode-standard-program.ts
 
 
 
@@ -12000,7 +12001,9 @@ function getRegisters(argsLength) {
     return regs;
 }
 
-;// CONCATENATED MODULE: ./packages/core/pvm-spi-decoder/index.ts
+;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/spi-decoder/index.ts
+
+
 
 
 ;// CONCATENATED MODULE: ./packages/jam/state/accumulation-output.ts
@@ -16264,408 +16267,658 @@ var status_Status;
 
 
 
-;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/memory/memory-index.ts
-
-
-const memory_index_tryAsMemoryIndex = (index) => {
-    debug_check `${index >= 0 && index <= memory_MAX_MEMORY_INDEX} Incorrect memory index: ${index}!`;
-    return opaque_asOpaqueType(index);
-};
-const memory_index_tryAsSbrkIndex = (index) => {
-    check `${index >= 0 && index <= MAX_MEMORY_INDEX + 1} Incorrect sbrk index: ${index}!`;
-    return asOpaqueType(index);
-};
-
-;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/memory/memory-consts.ts
-
-
-const memory_consts_PAGE_SIZE_SHIFT = 12;
-// PAGE_SIZE has to be a power of 2
-const memory_consts_PAGE_SIZE = 1 << memory_consts_PAGE_SIZE_SHIFT;
-const MIN_ALLOCATION_SHIFT = (() => {
-    const MIN_ALLOCATION_SHIFT = 7;
-    debug_check `${MIN_ALLOCATION_SHIFT >= 0 && MIN_ALLOCATION_SHIFT < memory_consts_PAGE_SIZE_SHIFT} incorrect minimal allocation shift`;
-    return MIN_ALLOCATION_SHIFT;
-})();
-const MIN_ALLOCATION_LENGTH = memory_consts_PAGE_SIZE >> MIN_ALLOCATION_SHIFT;
-const LAST_PAGE_NUMBER = (MEMORY_SIZE - memory_consts_PAGE_SIZE) / memory_consts_PAGE_SIZE;
-/** https://graypaper.fluffylabs.dev/#/68eaa1f/35a60235a602?v=0.6.4 */
-const memory_consts_RESERVED_NUMBER_OF_PAGES = 16;
-/** https://graypaper.fluffylabs.dev/#/68eaa1f/35a60235a602?v=0.6.4 */
-const MAX_NUMBER_OF_PAGES = MEMORY_SIZE / memory_consts_PAGE_SIZE;
-
-;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/memory/pages/page-utils.ts
+;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/program-decoder/mask.ts
 
 
-/** Ensure that given memory `index` is within `[0...PAGE_SIZE)` and can be used to index a page */
-const page_utils_tryAsPageIndex = (index) => {
-    check `${index >= 0 && index < PAGE_SIZE}, Incorect page index: ${index}!`;
-    return asOpaqueType(index);
-};
-/** Ensure that given `index` represents an index of one of the pages. */
-const page_utils_tryAsPageNumber = (index) => {
-    debug_check `${index >= 0 && index <= LAST_PAGE_NUMBER}, Incorect page number: ${index}!`;
-    return opaque_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
+ * 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.
  *
- * 2. Here is the definition of the modulo subscription operator:
- * https://graypaper.fluffylabs.dev/#/579bd12/073a00073a00
+ * https://graypaper.fluffylabs.dev/#/5f542d7/237201239801
  */
-function getNextPageNumber(pageNumber) {
-    const newPageNumber = pageNumber === LAST_PAGE_NUMBER ? 0 : pageNumber + 1;
-    return page_utils_tryAsPageNumber(newPageNumber);
-}
-
-;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/memory/memory-utils.ts
-
-
-
-function memory_memory_utils_alignToPageSize(length) {
-    return PAGE_SIZE * Math.ceil(length / PAGE_SIZE);
-}
-function memory_utils_getPageNumber(address) {
-    return page_utils_tryAsPageNumber(address >>> memory_consts_PAGE_SIZE_SHIFT);
-}
-function memory_utils_getStartPageIndex(address) {
-    return memory_index_tryAsMemoryIndex((address >>> memory_consts_PAGE_SIZE_SHIFT) << memory_consts_PAGE_SIZE_SHIFT);
-}
-function getStartPageIndexFromPageNumber(pageNumber) {
-    // >>> 0 is needed to avoid changing sign of the number
-    return memory_index_tryAsMemoryIndex((pageNumber << memory_consts_PAGE_SIZE_SHIFT) >>> 0);
-}
-
-;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/memory/errors.ts
-
-
-
-
-
-class errors_PageFault {
-    address;
-    isAccessFault;
-    constructor(address, isAccessFault = true) {
-        this.address = address;
-        this.isAccessFault = isAccessFault;
+class mask_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 = page_utils_tryAsPageNumber(maybePageNumber);
-        const startPageIndex = getStartPageIndexFromPageNumber(pageNumber);
-        return new errors_PageFault(numbers_tryAsU32(startPageIndex), isAccessFault);
+    isInstruction(index) {
+        return this.lookupTableForward[index] === 0;
     }
-    static fromMemoryIndex(maybeMemoryIndex, isAccessFault = false) {
-        const memoryIndex = memory_index_tryAsMemoryIndex(maybeMemoryIndex % MEMORY_SIZE);
-        const startPageIndex = memory_utils_getStartPageIndex(memoryIndex);
-        return new errors_PageFault(numbers_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);
     }
-}
-class OutOfBounds extends Error {
-    constructor() {
-        super("Out of bounds");
+    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 ChunkOverlap extends Error {
-    constructor() {
-        super("Memory chunks cannot overlap each other!");
+    static empty() {
+        return new mask_Mask(BitVec.empty(0));
     }
 }
-class ChunkTooLong extends Error {
-    constructor() {
-        super("Memory chunk is longer than the address range!");
+
+;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/args-decoder/argument-type.ts
+var argument_type_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";
+})(argument_type_ArgumentType || (argument_type_ArgumentType = {}));
+
+;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/args-decoder/decoders/nibbles-decoder.ts
+
+const MAX_REGISTER_INDEX = registers_NO_OF_REGISTERS - 1;
+const nibbles_decoder_MAX_LENGTH = 4;
+class nibbles_decoder_NibblesDecoder {
+    byte = new Int8Array(1);
+    setByte(byte) {
+        this.byte[0] = byte;
     }
-}
-class errors_IncorrectSbrkIndex extends Error {
-    constructor() {
-        super("Space between sbrk index and max heap index should be empty!");
+    getHighNibble() {
+        return (this.byte[0] & 0xf0) >>> 4;
     }
-}
-class errors_FinalizedBuilderModification extends Error {
-    constructor() {
-        super("MemoryBuilder was finalized and cannot be changed!");
+    getLowNibble() {
+        return this.byte[0] & 0x0f;
     }
-}
-class errors_ReservedMemoryFault extends Error {
-    constructor() {
-        super("You are trying to access reserved memory!");
+    getHighNibbleAsRegisterIndex() {
+        return Math.min(this.getHighNibble(), MAX_REGISTER_INDEX);
     }
-}
-class errors_PageNotExist extends Error {
-    constructor() {
-        super("You try to fill data on memory page that does not exist!");
+    getLowNibbleAsRegisterIndex() {
+        return Math.min(this.getLowNibble(), MAX_REGISTER_INDEX);
     }
-}
-class ChunkNotFound extends Error {
-    constructor() {
-        super("Chunk does not exist or is too short");
+    getHighNibbleAsLength() {
+        return Math.min(this.getHighNibble(), nibbles_decoder_MAX_LENGTH);
     }
-}
-class errors_OutOfMemory extends Error {
-    constructor() {
-        super("Out of memory");
+    getLowNibbleAsLength() {
+        return Math.min(this.getLowNibble(), nibbles_decoder_MAX_LENGTH);
     }
 }
 
-;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/memory/memory-range.ts
+;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/args-decoder/args-decoder.ts
 
 
 
-/**
- * A representation of open-ended range of consecutive indices in memory,
- * possibly empty or wrapping around.
- *
- * `[start, start + length)`
- */
-class memory_range_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 = memory_index_tryAsMemoryIndex((this.start + this.length) % MEMORY_SIZE);
-        if (length > 0) {
-            this.lastIndex = memory_index_tryAsMemoryIndex((this.end - 1 + MEMORY_SIZE) % MEMORY_SIZE);
-        }
+
+const IMMEDIATE_AND_OFFSET_MAX_LENGTH = 4;
+class args_decoder_ArgsDecoder {
+    nibblesDecoder = new NibblesDecoder();
+    offsetDecoder = new ImmediateDecoder();
+    code = new Uint8Array();
+    mask = Mask.empty();
+    reset(code, mask) {
+        this.code = code;
+        this.mask = mask;
     }
-    /** 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 memory_range_MemoryRange(start, length);
-    }
-    /** Checks if a range is empty (`length === 0`) */
-    isEmpty() {
-        return this.length === 0;
-    }
-    /** Returns true if the range is wrapped (`start` >= `end`) and is not empty */
-    isWrapped() {
-        return this.start >= this.end && !this.isEmpty();
-    }
-    /** 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;
-    }
-    /** Checks if this range overlaps with another range */
-    overlapsWith(other) {
-        if (this.lastIndex === null || other.lastIndex === null) {
-            return false;
+    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 memory_range_RESERVED_MEMORY_RANGE = memory_range_MemoryRange.fromStartAndLength(memory_index_tryAsMemoryIndex(0), memory_consts_RESERVED_NUMBER_OF_PAGES * memory_consts_PAGE_SIZE);
 
-;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/memory/page-range.ts
+;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/args-decoder/args-decoding-results.ts
 
 
 
-/**
- * A half-open range of memory pages. Similarly to [`MemoryRange`], can be empty
- * or wrapped around the memory.
- */
-class page_range_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 = page_utils_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 = memory_utils_getPageNumber(range.start);
-        if (range.isEmpty()) {
-            return new page_range_PageRange(startPage, 0);
-        }
-        // lastIndex is not null because we just ensured that the range is not empty
-        const pageWithLastIndex = memory_utils_getPageNumber(range.lastIndex ?? range.end);
-        const endPage = getNextPageNumber(pageWithLastIndex);
-        if ((startPage === endPage || startPage === pageWithLastIndex) && range.length > memory_consts_PAGE_SIZE) {
-            // full range
-            return new page_range_PageRange(startPage, MAX_NUMBER_OF_PAGES);
-        }
-        const length = startPage < endPage ? endPage - startPage : MAX_NUMBER_OF_PAGES - startPage + endPage;
-        return page_range_PageRange.fromStartAndLength(startPage, length);
-    }
-    /** 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 page_range_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;
-        }
-        return page >= this.start && page < this.end;
-    }
-    /** Checks if a range is empty (`length === 0`) */
-    isEmpty() {
-        return this.length === 0;
-    }
-    *[Symbol.iterator]() {
-        if (this.isEmpty()) {
-            return;
-        }
-        const end = this.end;
-        let i = this.start;
-        do {
-            yield i;
-            i = getNextPageNumber(i);
-        } while (i !== end);
-    }
-}
-
-;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/memory/pages/memory-page.ts
-
-class MemoryPage {
-    start;
-    constructor(pageNumber) {
-        this.start = getStartPageIndexFromPageNumber(pageNumber);
-    }
-}
-
-;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/memory/pages/readable-page.ts
+const ARGUMENT_TYPE_LENGTH = Object.keys(argument_type_ArgumentType).length / 2;
+const args_decoding_results_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;
+};
 
+;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/instruction.ts
+var instruction_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 || (instruction_Instruction = {}));
+const HIGHEST_INSTRUCTION_NUMBER = instruction_Instruction.MIN_U;
 
+;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/args-decoder/instruction-argument-type-map.ts
 
 
-class readable_page_ReadablePage extends MemoryPage {
-    data;
-    constructor(pageNumber, data) {
-        super(pageNumber);
-        this.data = data;
-    }
-    loadInto(result, startIndex, length) {
-        const endIndex = startIndex + length;
-        if (endIndex > memory_consts_PAGE_SIZE) {
-            return result_Result.error(errors_PageFault.fromMemoryIndex(this.start + memory_consts_PAGE_SIZE), () => `Page fault: read beyond page boundary at ${this.start + memory_consts_PAGE_SIZE}`);
-        }
-        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_Result.ok(result_OK);
-    }
-    storeFrom(_address, _data) {
-        return result_Result.error(errors_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;
-    }
-}
-
-;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/memory/pages/writeable-page.ts
-
-
-
-
-class writeable_page_WriteablePage extends MemoryPage {
-    buffer;
-    view;
-    constructor(pageNumber, initialData) {
-        super(pageNumber);
-        const dataLength = initialData?.length ?? 0;
-        const initialPageLength = Math.min(memory_consts_PAGE_SIZE, Math.max(dataLength, MIN_ALLOCATION_LENGTH));
-        this.buffer = new ArrayBuffer(initialPageLength, { maxByteLength: memory_consts_PAGE_SIZE });
-        this.view = new Uint8Array(this.buffer);
-        if (initialData !== undefined) {
-            this.view.set(initialData);
-        }
-    }
-    loadInto(result, startIndex, length) {
-        const endIndex = startIndex + length;
-        if (endIndex > memory_consts_PAGE_SIZE) {
-            return result_Result.error(errors_PageFault.fromMemoryIndex(this.start + memory_consts_PAGE_SIZE), () => `Page fault: read beyond page boundary at ${this.start + memory_consts_PAGE_SIZE}`);
-        }
-        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_Result.ok(result_OK);
-    }
-    storeFrom(startIndex, bytes) {
-        if (this.buffer.byteLength < startIndex + bytes.length && this.buffer.byteLength < memory_consts_PAGE_SIZE) {
-            const newLength = Math.min(memory_consts_PAGE_SIZE, Math.max(MIN_ALLOCATION_LENGTH, startIndex + bytes.length));
-            this.buffer.resize(newLength);
-        }
-        this.view.set(bytes, startIndex);
-        return result_Result.ok(result_OK);
-    }
-    setData(pageIndex, data) {
-        if (this.buffer.byteLength < pageIndex + data.length && this.buffer.byteLength < memory_consts_PAGE_SIZE) {
-            const newLength = Math.min(memory_consts_PAGE_SIZE, Math.max(MIN_ALLOCATION_LENGTH, pageIndex + data.length));
-            this.buffer.resize(newLength);
-        }
-        this.view.set(data, pageIndex);
-    }
-    isWriteable() {
-        return true;
-    }
-    getPageDump() {
-        return this.view;
-    }
-}
-
-;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/memory/pages/index.ts
-
-
-
-;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/memory/memory.ts
+const instruction_argument_type_map_instructionArgumentTypeMap = (() => {
+    const instructionArgumentTypeMap = new Array(HIGHEST_INSTRUCTION_NUMBER + 1);
+    instructionArgumentTypeMap[instruction_Instruction.TRAP] = argument_type_ArgumentType.NO_ARGUMENTS;
+    instructionArgumentTypeMap[instruction_Instruction.FALLTHROUGH] = argument_type_ArgumentType.NO_ARGUMENTS;
+    instructionArgumentTypeMap[instruction_Instruction.ECALLI] = argument_type_ArgumentType.ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.LOAD_IMM_64] = argument_type_ArgumentType.ONE_REGISTER_ONE_EXTENDED_WIDTH_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.STORE_IMM_U8] = argument_type_ArgumentType.TWO_IMMEDIATES;
+    instructionArgumentTypeMap[instruction_Instruction.STORE_IMM_U16] = argument_type_ArgumentType.TWO_IMMEDIATES;
+    instructionArgumentTypeMap[instruction_Instruction.STORE_IMM_U32] = argument_type_ArgumentType.TWO_IMMEDIATES;
+    instructionArgumentTypeMap[instruction_Instruction.STORE_IMM_U64] = argument_type_ArgumentType.TWO_IMMEDIATES;
+    instructionArgumentTypeMap[instruction_Instruction.JUMP] = argument_type_ArgumentType.ONE_OFFSET;
+    instructionArgumentTypeMap[instruction_Instruction.JUMP_IND] = argument_type_ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.LOAD_IMM] = argument_type_ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.LOAD_U8] = argument_type_ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.LOAD_I8] = argument_type_ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.LOAD_U16] = argument_type_ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.LOAD_I16] = argument_type_ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.LOAD_U32] = argument_type_ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.LOAD_I32] = argument_type_ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.LOAD_U64] = argument_type_ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.STORE_U8] = argument_type_ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.STORE_U16] = argument_type_ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.STORE_U32] = argument_type_ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.STORE_U64] = argument_type_ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.STORE_IMM_IND_U8] = argument_type_ArgumentType.ONE_REGISTER_TWO_IMMEDIATES;
+    instructionArgumentTypeMap[instruction_Instruction.STORE_IMM_IND_U16] = argument_type_ArgumentType.ONE_REGISTER_TWO_IMMEDIATES;
+    instructionArgumentTypeMap[instruction_Instruction.STORE_IMM_IND_U32] = argument_type_ArgumentType.ONE_REGISTER_TWO_IMMEDIATES;
+    instructionArgumentTypeMap[instruction_Instruction.STORE_IMM_IND_U64] = argument_type_ArgumentType.ONE_REGISTER_TWO_IMMEDIATES;
+    instructionArgumentTypeMap[instruction_Instruction.LOAD_IMM_JUMP] = argument_type_ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
+    instructionArgumentTypeMap[instruction_Instruction.BRANCH_EQ_IMM] = argument_type_ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
+    instructionArgumentTypeMap[instruction_Instruction.BRANCH_NE_IMM] = argument_type_ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
+    instructionArgumentTypeMap[instruction_Instruction.BRANCH_LT_U_IMM] = argument_type_ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
+    instructionArgumentTypeMap[instruction_Instruction.BRANCH_LE_U_IMM] = argument_type_ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
+    instructionArgumentTypeMap[instruction_Instruction.BRANCH_GE_U_IMM] = argument_type_ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
+    instructionArgumentTypeMap[instruction_Instruction.BRANCH_GT_U_IMM] = argument_type_ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
+    instructionArgumentTypeMap[instruction_Instruction.BRANCH_LT_S_IMM] = argument_type_ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
+    instructionArgumentTypeMap[instruction_Instruction.BRANCH_LE_S_IMM] = argument_type_ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
+    instructionArgumentTypeMap[instruction_Instruction.BRANCH_GE_S_IMM] = argument_type_ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
+    instructionArgumentTypeMap[instruction_Instruction.BRANCH_GT_S_IMM] = argument_type_ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
+    instructionArgumentTypeMap[instruction_Instruction.MOVE_REG] = argument_type_ArgumentType.TWO_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.SBRK] = argument_type_ArgumentType.TWO_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.COUNT_SET_BITS_64] = argument_type_ArgumentType.TWO_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.COUNT_SET_BITS_32] = argument_type_ArgumentType.TWO_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.LEADING_ZERO_BITS_64] = argument_type_ArgumentType.TWO_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.LEADING_ZERO_BITS_32] = argument_type_ArgumentType.TWO_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.TRAILING_ZERO_BITS_64] = argument_type_ArgumentType.TWO_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.TRAILING_ZERO_BITS_32] = argument_type_ArgumentType.TWO_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.SIGN_EXTEND_8] = argument_type_ArgumentType.TWO_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.SIGN_EXTEND_16] = argument_type_ArgumentType.TWO_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.ZERO_EXTEND_16] = argument_type_ArgumentType.TWO_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.REVERSE_BYTES] = argument_type_ArgumentType.TWO_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.STORE_IND_U8] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.STORE_IND_U16] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.STORE_IND_U32] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.STORE_IND_U64] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.LOAD_IND_U8] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.LOAD_IND_I8] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.LOAD_IND_U16] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.LOAD_IND_I16] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.LOAD_IND_U32] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.LOAD_IND_I32] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.LOAD_IND_U64] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.ADD_IMM_32] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.ADD_IMM_64] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.AND_IMM] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.XOR_IMM] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.OR_IMM] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.MUL_IMM_32] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.MUL_IMM_64] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.SET_LT_U_IMM] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.SET_LT_S_IMM] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.SHLO_L_IMM_32] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.SHLO_R_IMM_32] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.SHAR_R_IMM_32] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.NEG_ADD_IMM_32] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.SHLO_L_IMM_64] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.SHLO_R_IMM_64] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.SHAR_R_IMM_64] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.NEG_ADD_IMM_64] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.SET_GT_U_IMM] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.SET_GT_S_IMM] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.SHLO_L_IMM_ALT_32] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.SHLO_R_IMM_ALT_32] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.SHAR_R_IMM_ALT_32] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.SHLO_L_IMM_ALT_64] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.SHLO_R_IMM_ALT_64] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.SHAR_R_IMM_ALT_64] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.CMOV_IZ_IMM] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.CMOV_NZ_IMM] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.ROT_R_64_IMM] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.ROT_R_64_IMM_ALT] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.ROT_R_32_IMM] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.ROT_R_32_IMM_ALT] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    instructionArgumentTypeMap[instruction_Instruction.BRANCH_EQ] = argument_type_ArgumentType.TWO_REGISTERS_ONE_OFFSET;
+    instructionArgumentTypeMap[instruction_Instruction.BRANCH_NE] = argument_type_ArgumentType.TWO_REGISTERS_ONE_OFFSET;
+    instructionArgumentTypeMap[instruction_Instruction.BRANCH_LT_U] = argument_type_ArgumentType.TWO_REGISTERS_ONE_OFFSET;
+    instructionArgumentTypeMap[instruction_Instruction.BRANCH_LT_S] = argument_type_ArgumentType.TWO_REGISTERS_ONE_OFFSET;
+    instructionArgumentTypeMap[instruction_Instruction.BRANCH_GE_U] = argument_type_ArgumentType.TWO_REGISTERS_ONE_OFFSET;
+    instructionArgumentTypeMap[instruction_Instruction.BRANCH_GE_S] = argument_type_ArgumentType.TWO_REGISTERS_ONE_OFFSET;
+    instructionArgumentTypeMap[instruction_Instruction.LOAD_IMM_JUMP_IND] = argument_type_ArgumentType.TWO_REGISTERS_TWO_IMMEDIATES;
+    instructionArgumentTypeMap[instruction_Instruction.ADD_32] = argument_type_ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.ADD_64] = argument_type_ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.SUB_32] = argument_type_ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.SUB_64] = argument_type_ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.AND] = argument_type_ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.XOR] = argument_type_ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.OR] = argument_type_ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.MUL_32] = argument_type_ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.MUL_64] = argument_type_ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.MUL_UPPER_S_S] = argument_type_ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.MUL_UPPER_U_U] = argument_type_ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.MUL_UPPER_S_U] = argument_type_ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.DIV_U_32] = argument_type_ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.DIV_S_32] = argument_type_ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.REM_U_32] = argument_type_ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.REM_S_32] = argument_type_ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.DIV_U_64] = argument_type_ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.DIV_S_64] = argument_type_ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.REM_U_64] = argument_type_ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.REM_S_64] = argument_type_ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.SET_LT_U] = argument_type_ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.SET_LT_S] = argument_type_ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.SHLO_L_32] = argument_type_ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.SHLO_R_32] = argument_type_ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.SHAR_R_32] = argument_type_ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.SHLO_L_64] = argument_type_ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.SHLO_R_64] = argument_type_ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.SHAR_R_64] = argument_type_ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.CMOV_IZ] = argument_type_ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.CMOV_NZ] = argument_type_ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.ROT_L_64] = argument_type_ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.ROT_L_32] = argument_type_ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.ROT_R_64] = argument_type_ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.ROT_R_32] = argument_type_ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.AND_INV] = argument_type_ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.OR_INV] = argument_type_ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.XNOR] = argument_type_ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.MAX] = argument_type_ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.MAX_U] = argument_type_ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.MIN] = argument_type_ArgumentType.THREE_REGISTERS;
+    instructionArgumentTypeMap[instruction_Instruction.MIN_U] = argument_type_ArgumentType.THREE_REGISTERS;
+    return instructionArgumentTypeMap;
+})();
 
+;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/args-decoder/index.ts
 
 
 
@@ -16674,1380 +16927,993 @@ class writeable_page_WriteablePage extends MemoryPage {
 
 
 
+;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/basic-blocks/is-termination-instruction.ts
 
+const is_termination_instruction_terminationInstructions = (() => {
+    const terminationInstructions = new Array(HIGHEST_INSTRUCTION_NUMBER + 1);
+    terminationInstructions.fill(false);
+    terminationInstructions[instruction_Instruction.TRAP] = true;
+    terminationInstructions[instruction_Instruction.FALLTHROUGH] = true;
+    terminationInstructions[instruction_Instruction.JUMP] = true;
+    terminationInstructions[instruction_Instruction.JUMP_IND] = true;
+    terminationInstructions[instruction_Instruction.LOAD_IMM_JUMP] = true;
+    terminationInstructions[instruction_Instruction.LOAD_IMM_JUMP_IND] = true;
+    terminationInstructions[instruction_Instruction.BRANCH_EQ] = true;
+    terminationInstructions[instruction_Instruction.BRANCH_NE] = true;
+    terminationInstructions[instruction_Instruction.BRANCH_GE_U] = true;
+    terminationInstructions[instruction_Instruction.BRANCH_GE_S] = true;
+    terminationInstructions[instruction_Instruction.BRANCH_LT_U] = true;
+    terminationInstructions[instruction_Instruction.BRANCH_LT_S] = true;
+    terminationInstructions[instruction_Instruction.BRANCH_EQ_IMM] = true;
+    terminationInstructions[instruction_Instruction.BRANCH_NE_IMM] = true;
+    terminationInstructions[instruction_Instruction.BRANCH_LT_U_IMM] = true;
+    terminationInstructions[instruction_Instruction.BRANCH_LT_S_IMM] = true;
+    terminationInstructions[instruction_Instruction.BRANCH_LE_U_IMM] = true;
+    terminationInstructions[instruction_Instruction.BRANCH_LE_S_IMM] = true;
+    terminationInstructions[instruction_Instruction.BRANCH_GE_U_IMM] = true;
+    terminationInstructions[instruction_Instruction.BRANCH_GE_S_IMM] = true;
+    terminationInstructions[instruction_Instruction.BRANCH_GT_U_IMM] = true;
+    terminationInstructions[instruction_Instruction.BRANCH_GT_S_IMM] = true;
+    return terminationInstructions;
+})();
 
+;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/basic-blocks/basic-blocks.ts
 
-var AccessType;
-(function (AccessType) {
-    AccessType[AccessType["READ"] = 0] = "READ";
-    AccessType[AccessType["WRITE"] = 1] = "WRITE";
-})(AccessType || (AccessType = {}));
-const memory_logger = Logger.new(import.meta.filename, "pvm:mem");
-class memory_Memory {
-    sbrkIndex;
-    virtualSbrkIndex;
-    endHeapIndex;
-    memory;
-    static fromInitialMemory(initialMemoryState) {
-        return new memory_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.ok(OK);
-        }
-        memory_logger.insane `MEM[${address}] <- ${BytesBlob.blobFrom(bytes)}`;
-        const pagesResult = this.getPages(address, bytes.length, AccessType.WRITE);
-        if (pagesResult.isError) {
-            return Result.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);
-            const bytesToWrite = Math.min(PAGE_SIZE - pageStartIndex, bytesLeft);
-            const sourceStartIndex = currentPosition - address;
-            const source = bytes.subarray(sourceStartIndex, sourceStartIndex + bytesToWrite);
-            page.storeFrom(pageStartIndex, source);
-            currentPosition += bytesToWrite;
-            bytesLeft -= bytesToWrite;
-        }
-        return Result.ok(OK);
-    }
-    getPages(startAddress, length, accessType) {
-        if (length === 0) {
-            return Result.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.error(PageFault.fromPageNumber(pageNumber, true), () => `Page fault: attempted to access reserved page ${pageNumber}`);
-            }
-            const page = this.memory.get(pageNumber);
-            if (page === undefined) {
-                return Result.error(PageFault.fromPageNumber(pageNumber), () => `Page fault: page ${pageNumber} not allocated`);
-            }
-            if (accessType === AccessType.WRITE && !page.isWriteable()) {
-                return Result.error(PageFault.fromPageNumber(pageNumber, true), () => `Page fault: attempted to write to read-only page ${pageNumber}`);
+class basic_blocks_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.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.ok(OK);
-        }
-        const pagesResult = this.getPages(startAddress, result.length, AccessType.READ);
-        if (pagesResult.isError) {
-            return Result.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);
-            const bytesToRead = Math.min(PAGE_SIZE - pageStartIndex, bytesLeft);
-            const destinationStartIndex = currentPosition - startAddress;
-            const destination = result.subarray(destinationStartIndex);
-            page.loadInto(destination, pageStartIndex, bytesToRead);
-            currentPosition += bytesToRead;
-            bytesLeft -= bytesToRead;
-        }
-        memory_logger.insane `MEM[${startAddress}] => ${BytesBlob.blobFrom(result)}`;
-        return Result.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(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;
-        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);
     }
 }
 
-;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/memory/memory-builder.ts
-
-
-
-
-
-
+;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/basic-blocks/index.ts
 
 
+;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/assemblify.ts
 
 
-class memory_builder_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 === 0} start needs to be a multiple of page size (${PAGE_SIZE})`;
-        check `${end % PAGE_SIZE === 0} end needs to be a multiple of page size (${PAGE_SIZE})`;
-        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, (i + 1) * PAGE_SIZE);
-            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 === 0} start needs to be a multiple of page size (${PAGE_SIZE})`;
-        check `${end % PAGE_SIZE === 0} end needs to be a multiple of page size (${PAGE_SIZE})`;
-        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, (i + 1) * PAGE_SIZE);
-            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;
-        const remainingSpaceOnPage = PAGE_SIZE - 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 instructionsWithoutArgs = [
+    [instruction_Instruction.TRAP, 1],
+    [instruction_Instruction.FALLTHROUGH, 1],
+];
+const instructionsWithOneImmediate = [[instruction_Instruction.ECALLI, 1]];
+const instructionsWithOneRegisterAndOneExtendedWidthImmediate = [[instruction_Instruction.LOAD_IMM_64, 1]];
+const instructionsWithTwoImmediates = [
+    [instruction_Instruction.STORE_IMM_U8, 1],
+    [instruction_Instruction.STORE_IMM_U16, 1],
+    [instruction_Instruction.STORE_IMM_U32, 1],
+    [instruction_Instruction.STORE_IMM_U64, 1],
+];
+const instructionsWithOneOffset = [[instruction_Instruction.JUMP, 1]];
+const instructionsWithOneRegisterAndOneImmediate = [
+    [instruction_Instruction.JUMP_IND, 1],
+    [instruction_Instruction.LOAD_IMM, 1],
+    [instruction_Instruction.LOAD_U8, 1],
+    [instruction_Instruction.LOAD_I8, 1],
+    [instruction_Instruction.LOAD_U16, 1],
+    [instruction_Instruction.LOAD_I16, 1],
+    [instruction_Instruction.LOAD_U32, 1],
+    [instruction_Instruction.LOAD_I32, 1],
+    [instruction_Instruction.LOAD_U64, 1],
+    [instruction_Instruction.STORE_U8, 1],
+    [instruction_Instruction.STORE_U16, 1],
+    [instruction_Instruction.STORE_U32, 1],
+    [instruction_Instruction.STORE_U64, 1],
+];
+const instructionsWithOneRegisterAndTwoImmediate = [
+    [instruction_Instruction.STORE_IMM_IND_U8, 1],
+    [instruction_Instruction.STORE_IMM_IND_U16, 1],
+    [instruction_Instruction.STORE_IMM_IND_U32, 1],
+    [instruction_Instruction.STORE_IMM_IND_U64, 1],
+];
+const instructionsWithOneRegisterOneImmediateAndOneOffset = [
+    [instruction_Instruction.LOAD_IMM_JUMP, 1],
+    [instruction_Instruction.BRANCH_EQ_IMM, 1],
+    [instruction_Instruction.BRANCH_NE_IMM, 1],
+    [instruction_Instruction.BRANCH_LT_U_IMM, 1],
+    [instruction_Instruction.BRANCH_LE_U_IMM, 1],
+    [instruction_Instruction.BRANCH_GE_U_IMM, 1],
+    [instruction_Instruction.BRANCH_GT_U_IMM, 1],
+    [instruction_Instruction.BRANCH_LT_S_IMM, 1],
+    [instruction_Instruction.BRANCH_LE_S_IMM, 1],
+    [instruction_Instruction.BRANCH_GE_S_IMM, 1],
+    [instruction_Instruction.BRANCH_GT_S_IMM, 1],
+];
+const instructionsWithTwoRegisters = [
+    [instruction_Instruction.MOVE_REG, 1],
+    [instruction_Instruction.SBRK, 1],
+    [instruction_Instruction.COUNT_SET_BITS_64, 1],
+    [instruction_Instruction.COUNT_SET_BITS_32, 1],
+    [instruction_Instruction.LEADING_ZERO_BITS_64, 1],
+    [instruction_Instruction.LEADING_ZERO_BITS_32, 1],
+    [instruction_Instruction.TRAILING_ZERO_BITS_64, 1],
+    [instruction_Instruction.TRAILING_ZERO_BITS_32, 1],
+    [instruction_Instruction.SIGN_EXTEND_8, 1],
+    [instruction_Instruction.SIGN_EXTEND_16, 1],
+    [instruction_Instruction.ZERO_EXTEND_16, 1],
+    [instruction_Instruction.REVERSE_BYTES, 1],
+];
+const instructionsWithTwoRegistersAndOneImmediate = [
+    [instruction_Instruction.STORE_IND_U8, 1],
+    [instruction_Instruction.STORE_IND_U16, 1],
+    [instruction_Instruction.STORE_IND_U32, 1],
+    [instruction_Instruction.STORE_IND_U64, 1],
+    [instruction_Instruction.LOAD_IND_U8, 1],
+    [instruction_Instruction.LOAD_IND_I8, 1],
+    [instruction_Instruction.LOAD_IND_U16, 1],
+    [instruction_Instruction.LOAD_IND_I16, 1],
+    [instruction_Instruction.LOAD_IND_U32, 1],
+    [instruction_Instruction.LOAD_IND_I32, 1],
+    [instruction_Instruction.LOAD_IND_U64, 1],
+    [instruction_Instruction.ADD_IMM_32, 1],
+    [instruction_Instruction.AND_IMM, 1],
+    [instruction_Instruction.XOR_IMM, 1],
+    [instruction_Instruction.OR_IMM, 1],
+    [instruction_Instruction.MUL_IMM_32, 1],
+    [instruction_Instruction.SET_LT_U_IMM, 1],
+    [instruction_Instruction.SET_LT_S_IMM, 1],
+    [instruction_Instruction.SHLO_L_IMM_32, 1],
+    [instruction_Instruction.SHLO_R_IMM_32, 1],
+    [instruction_Instruction.SHAR_R_IMM_32, 1],
+    [instruction_Instruction.NEG_ADD_IMM_32, 1],
+    [instruction_Instruction.SET_GT_U_IMM, 1],
+    [instruction_Instruction.SET_GT_S_IMM, 1],
+    [instruction_Instruction.SHLO_L_IMM_ALT_32, 1],
+    [instruction_Instruction.SHLO_R_IMM_ALT_32, 1],
+    [instruction_Instruction.SHAR_R_IMM_ALT_32, 1],
+    [instruction_Instruction.CMOV_IZ_IMM, 1],
+    [instruction_Instruction.CMOV_NZ_IMM, 1],
+    [instruction_Instruction.ADD_IMM_64, 1],
+    [instruction_Instruction.MUL_IMM_64, 1],
+    [instruction_Instruction.SHLO_L_IMM_64, 1],
+    [instruction_Instruction.SHLO_R_IMM_64, 1],
+    [instruction_Instruction.SHAR_R_IMM_64, 1],
+    [instruction_Instruction.NEG_ADD_IMM_64, 1],
+    [instruction_Instruction.SHLO_L_IMM_ALT_64, 1],
+    [instruction_Instruction.SHLO_R_IMM_ALT_64, 1],
+    [instruction_Instruction.SHAR_R_IMM_ALT_64, 1],
+    [instruction_Instruction.ROT_R_64_IMM, 1],
+    [instruction_Instruction.ROT_R_64_IMM_ALT, 1],
+    [instruction_Instruction.ROT_R_32_IMM, 1],
+    [instruction_Instruction.ROT_R_32_IMM_ALT, 1],
+];
+const instructionsWithTwoRegistersAndOneOffset = [
+    [instruction_Instruction.BRANCH_EQ, 1],
+    [instruction_Instruction.BRANCH_NE, 1],
+    [instruction_Instruction.BRANCH_LT_U, 1],
+    [instruction_Instruction.BRANCH_LT_S, 1],
+    [instruction_Instruction.BRANCH_GE_U, 1],
+    [instruction_Instruction.BRANCH_GE_S, 1],
+];
+const instructionWithTwoRegistersAndTwoImmediates = [[instruction_Instruction.LOAD_IMM_JUMP_IND, 1]];
+const instructionsWithThreeRegisters = [
+    [instruction_Instruction.ADD_32, 1],
+    [instruction_Instruction.SUB_32, 1],
+    [instruction_Instruction.MUL_32, 1],
+    [instruction_Instruction.DIV_U_32, 1],
+    [instruction_Instruction.DIV_S_32, 1],
+    [instruction_Instruction.REM_U_32, 1],
+    [instruction_Instruction.REM_S_32, 1],
+    [instruction_Instruction.SHLO_L_32, 1],
+    [instruction_Instruction.SHLO_R_32, 1],
+    [instruction_Instruction.SHAR_R_32, 1],
+    [instruction_Instruction.ADD_64, 1],
+    [instruction_Instruction.SUB_64, 1],
+    [instruction_Instruction.MUL_64, 1],
+    [instruction_Instruction.DIV_U_64, 1],
+    [instruction_Instruction.DIV_S_64, 1],
+    [instruction_Instruction.REM_U_64, 1],
+    [instruction_Instruction.REM_S_64, 1],
+    [instruction_Instruction.SHLO_L_64, 1],
+    [instruction_Instruction.SHLO_R_64, 1],
+    [instruction_Instruction.SHAR_R_64, 1],
+    [instruction_Instruction.AND, 1],
+    [instruction_Instruction.XOR, 1],
+    [instruction_Instruction.OR, 1],
+    [instruction_Instruction.MUL_UPPER_S_S, 1],
+    [instruction_Instruction.MUL_UPPER_U_U, 1],
+    [instruction_Instruction.MUL_UPPER_S_U, 1],
+    [instruction_Instruction.SET_LT_U, 1],
+    [instruction_Instruction.SET_LT_S, 1],
+    [instruction_Instruction.CMOV_IZ, 1],
+    [instruction_Instruction.CMOV_NZ, 1],
+    [instruction_Instruction.ROT_L_64, 1],
+    [instruction_Instruction.ROT_L_32, 1],
+    [instruction_Instruction.ROT_R_64, 1],
+    [instruction_Instruction.ROT_R_32, 1],
+    [instruction_Instruction.AND_INV, 1],
+    [instruction_Instruction.OR_INV, 1],
+    [instruction_Instruction.XNOR, 1],
+    [instruction_Instruction.MAX, 1],
+    [instruction_Instruction.MAX_U, 1],
+    [instruction_Instruction.MIN, 1],
+    [instruction_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_assemblify(program, mask) {
+    return program.reduce((acc, byte, index) => {
+        if (mask.isInstruction(index)) {
+            acc.push([Instruction[byte]]);
         }
-        const memory = Memory.fromInitialMemory({
-            memory: this.initialMemory,
-            sbrkIndex: tryAsSbrkIndex(startHeapIndex),
-            endHeapIndex,
-        });
-        this.isFinalized = true;
-        return memory;
-    }
+        else {
+            acc[acc.length - 1].push(byte);
+        }
+        return acc;
+    }, []);
 }
 
-;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/memory/index.ts
-
-
-
-
-;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/registers.ts
+;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/gas.ts
 
 
-const REGISTER_SIZE_SHIFT = 3; // x << 3 === x * 8
-const tryAsRegisterIndex = (index) => {
-    check `${index >= 0 && index < NO_OF_REGISTERS} Incorrect register index: ${index}!`;
-    return asOpaqueType(index);
-};
-class registers_Registers {
-    bytes;
-    asSigned;
-    asUnsigned;
-    constructor(bytes = safeAllocUint8Array(NO_OF_REGISTERS << REGISTER_SIZE_SHIFT)) {
-        this.bytes = bytes;
-        check `${bytes.length === NO_OF_REGISTERS << REGISTER_SIZE_SHIFT} Invalid size of registers array.`;
-        this.asSigned = new BigInt64Array(bytes.buffer, bytes.byteOffset);
-        this.asUnsigned = new BigUint64Array(bytes.buffer, bytes.byteOffset);
-    }
-    getAllEncoded() {
-        return this.bytes;
+/** Create a new gas counter instance depending on the gas value. */
+function gas_gasCounter(gas) {
+    return new GasCounterU64(tryAsU64(gas));
+}
+class GasCounterU64 {
+    gas;
+    initialGas;
+    constructor(gas) {
+        this.gas = gas;
+        this.initialGas = tryAsGas(gas);
     }
-    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);
+    set(g) {
+        this.gas = tryAsU64(g);
     }
-    static fromBytes(bytes) {
-        check `${bytes.length === NO_OF_REGISTERS << REGISTER_SIZE_SHIFT} Invalid size of registers array.`;
-        return new registers_Registers(bytes);
+    get() {
+        return tryAsGas(this.gas);
     }
-    getBytesAsLittleEndian(index, len) {
-        const offset = index << REGISTER_SIZE_SHIFT;
-        return this.bytes.subarray(offset, offset + len);
+    sub(g) {
+        const result = this.gas - tryAsU64(g);
+        if (result >= 0n) {
+            this.gas = tryAsU64(result);
+            return false;
+        }
+        this.gas = tryAsU64(0n);
+        return true;
     }
-    copyFrom(regs) {
-        const array = regs instanceof BigUint64Array ? regs : regs.asUnsigned;
-        this.asUnsigned.set(array);
-    }
-    reset() {
-        for (let i = 0; i < NO_OF_REGISTERS; i++) {
-            this.asUnsigned[i] = 0n;
+    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);
     }
-    getLowerU32(registerIndex) {
-        return Number(this.asUnsigned[registerIndex] & 0xffffffffn);
-    }
-    getLowerI32(registerIndex) {
-        return Number(this.getLowerU32(registerIndex)) >> 0;
+}
+
+;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/instruction-gas-map.ts
+
+
+const instruction_gas_map_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;
     }
-    setU32(registerIndex, value) {
-        this.asUnsigned[registerIndex] = registers_signExtend32To64(value);
+    return instructionGasMap;
+})();
+
+;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/memory/memory-index.ts
+
+
+const memory_index_tryAsMemoryIndex = (index) => {
+    debug_check `${index >= 0 && index <= memory_MAX_MEMORY_INDEX} Incorrect memory index: ${index}!`;
+    return opaque_asOpaqueType(index);
+};
+const memory_index_tryAsSbrkIndex = (index) => {
+    check `${index >= 0 && index <= MAX_MEMORY_INDEX + 1} Incorrect sbrk index: ${index}!`;
+    return asOpaqueType(index);
+};
+
+;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/memory/memory-consts.ts
+
+
+const memory_consts_PAGE_SIZE_SHIFT = 12;
+// PAGE_SIZE has to be a power of 2
+const memory_consts_PAGE_SIZE = 1 << memory_consts_PAGE_SIZE_SHIFT;
+const MIN_ALLOCATION_SHIFT = (() => {
+    const MIN_ALLOCATION_SHIFT = 7;
+    debug_check `${MIN_ALLOCATION_SHIFT >= 0 && MIN_ALLOCATION_SHIFT < memory_consts_PAGE_SIZE_SHIFT} incorrect minimal allocation shift`;
+    return MIN_ALLOCATION_SHIFT;
+})();
+const MIN_ALLOCATION_LENGTH = memory_consts_PAGE_SIZE >> MIN_ALLOCATION_SHIFT;
+const LAST_PAGE_NUMBER = (MEMORY_SIZE - memory_consts_PAGE_SIZE) / memory_consts_PAGE_SIZE;
+/** https://graypaper.fluffylabs.dev/#/68eaa1f/35a60235a602?v=0.6.4 */
+const memory_consts_RESERVED_NUMBER_OF_PAGES = 16;
+/** https://graypaper.fluffylabs.dev/#/68eaa1f/35a60235a602?v=0.6.4 */
+const MAX_NUMBER_OF_PAGES = MEMORY_SIZE / memory_consts_PAGE_SIZE;
+
+;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/memory/pages/page-utils.ts
+
+
+/** Ensure that given memory `index` is within `[0...PAGE_SIZE)` and can be used to index a page */
+const page_utils_tryAsPageIndex = (index) => {
+    check `${index >= 0 && index < PAGE_SIZE}, Incorect page index: ${index}!`;
+    return asOpaqueType(index);
+};
+/** Ensure that given `index` represents an index of one of the pages. */
+const page_utils_tryAsPageNumber = (index) => {
+    debug_check `${index >= 0 && index <= LAST_PAGE_NUMBER}, Incorect page number: ${index}!`;
+    return opaque_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
+ *
+ * 2. Here is the definition of the modulo subscription operator:
+ * https://graypaper.fluffylabs.dev/#/579bd12/073a00073a00
+ */
+function getNextPageNumber(pageNumber) {
+    const newPageNumber = pageNumber === LAST_PAGE_NUMBER ? 0 : pageNumber + 1;
+    return page_utils_tryAsPageNumber(newPageNumber);
+}
+
+;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/memory/memory-utils.ts
+
+
+
+function memory_memory_utils_alignToPageSize(length) {
+    return PAGE_SIZE * Math.ceil(length / PAGE_SIZE);
+}
+function memory_utils_getPageNumber(address) {
+    return page_utils_tryAsPageNumber(address >>> memory_consts_PAGE_SIZE_SHIFT);
+}
+function memory_utils_getStartPageIndex(address) {
+    return memory_index_tryAsMemoryIndex((address >>> memory_consts_PAGE_SIZE_SHIFT) << memory_consts_PAGE_SIZE_SHIFT);
+}
+function getStartPageIndexFromPageNumber(pageNumber) {
+    // >>> 0 is needed to avoid changing sign of the number
+    return memory_index_tryAsMemoryIndex((pageNumber << memory_consts_PAGE_SIZE_SHIFT) >>> 0);
+}
+
+;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/memory/errors.ts
+
+
+
+
+
+class errors_PageFault {
+    address;
+    isAccessFault;
+    constructor(address, isAccessFault = true) {
+        this.address = address;
+        this.isAccessFault = isAccessFault;
     }
-    setI32(registerIndex, value) {
-        this.asSigned[registerIndex] = registers_signExtend32To64(value);
+    static fromPageNumber(maybePageNumber, isAccessFault = false) {
+        const pageNumber = page_utils_tryAsPageNumber(maybePageNumber);
+        const startPageIndex = getStartPageIndexFromPageNumber(pageNumber);
+        return new errors_PageFault(numbers_tryAsU32(startPageIndex), isAccessFault);
     }
-    getU64(registerIndex) {
-        return this.asUnsigned[registerIndex];
+    static fromMemoryIndex(maybeMemoryIndex, isAccessFault = false) {
+        const memoryIndex = memory_index_tryAsMemoryIndex(maybeMemoryIndex % MEMORY_SIZE);
+        const startPageIndex = memory_utils_getStartPageIndex(memoryIndex);
+        return new errors_PageFault(numbers_tryAsU32(startPageIndex), isAccessFault);
     }
-    getI64(registerIndex) {
-        return this.asSigned[registerIndex];
+}
+class OutOfBounds extends Error {
+    constructor() {
+        super("Out of bounds");
     }
-    setU64(registerIndex, value) {
-        this.asUnsigned[registerIndex] = value;
+}
+class ChunkOverlap extends Error {
+    constructor() {
+        super("Memory chunks cannot overlap each other!");
     }
-    setI64(registerIndex, value) {
-        this.asSigned[registerIndex] = value;
+}
+class ChunkTooLong extends Error {
+    constructor() {
+        super("Memory chunk is longer than the address range!");
     }
-    getAllU64() {
-        return this.asUnsigned;
+}
+class errors_IncorrectSbrkIndex extends Error {
+    constructor() {
+        super("Space between sbrk index and max heap index should be empty!");
     }
 }
-function registers_signExtend32To64(value) {
-    // Convert to BigInt if the value is a number
-    const bigValue = typeof value === "number" ? BigInt(value) : value;
-    // Ensure the value is treated as a 32-bit integer
-    const mask32 = BigInt(0xffffffff);
-    const signBit = BigInt(0x80000000);
-    const maskedValue = bigValue & mask32;
-    // Check the sign bit and extend the sign if necessary
-    if ((maskedValue & signBit) !== BigInt(0)) {
-        // If the sign bit is set, extend with ones
-        return maskedValue | ~mask32;
+class errors_FinalizedBuilderModification extends Error {
+    constructor() {
+        super("MemoryBuilder was finalized and cannot be changed!");
     }
-    // If the sign bit is not set, return as is
-    return maskedValue;
 }
-
-;// CONCATENATED MODULE: ./packages/core/pvm-program/program.ts
-
-
-
-
-
-class program_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_Program(code, regs, memory, metadata);
+class errors_ReservedMemoryFault extends Error {
+    constructor() {
+        super("You are trying to access reserved memory!");
     }
-    static fromGeneric(blob, hasMetadata) {
-        const { code, metadata } = hasMetadata ? extractCodeAndMetadata(blob) : { code: blob };
-        const regs = new Registers();
-        const memory = new Memory();
-        return new program_Program(code, regs, memory, metadata);
+}
+class errors_PageNotExist extends Error {
+    constructor() {
+        super("You try to fill data on memory page that does not exist!");
     }
-    constructor(code, registers, memory, metadata = new Uint8Array()) {
-        this.code = code;
-        this.registers = registers;
-        this.memory = memory;
-        this.metadata = metadata;
+}
+class ChunkNotFound extends Error {
+    constructor() {
+        super("Chunk does not exist or is too short");
     }
 }
-/**
- * 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 };
+class errors_OutOfMemory extends Error {
+    constructor() {
+        super("Out of memory");
+    }
 }
 
-;// CONCATENATED MODULE: ./packages/core/pvm-program/index.ts
-
+;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/memory/memory-range.ts
 
-;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/program-decoder/mask.ts
 
 
 /**
- * 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.
+ * A representation of open-ended range of consecutive indices in memory,
+ * possibly empty or wrapping around.
  *
- * https://graypaper.fluffylabs.dev/#/5f542d7/237201239801
+ * `[start, start + length)`
  */
-class mask_Mask {
+class memory_range_MemoryRange {
+    start;
+    length;
     /**
-     * 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.
+     * Exclusive end index of the range.
      *
-     * 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`.
+     * NOTE: The index may be wrapped around and smaller than `start`!
      */
-    lookupTableForward;
-    constructor(mask) {
-        this.lookupTableForward = this.buildLookupTableForward(mask);
+    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 = memory_index_tryAsMemoryIndex((this.start + this.length) % MEMORY_SIZE);
+        if (length > 0) {
+            this.lastIndex = memory_index_tryAsMemoryIndex((this.end - 1 + MEMORY_SIZE) % MEMORY_SIZE);
+        }
     }
-    isInstruction(index) {
-        return this.lookupTableForward[index] === 0;
+    /** 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 memory_range_MemoryRange(start, length);
     }
-    getNoOfBytesToNextInstruction(index) {
-        check `${index >= 0} index (${index}) cannot be a negative number`;
-        return Math.min(this.lookupTableForward[index] ?? 0, MAX_INSTRUCTION_DISTANCE);
+    /** Checks if a range is empty (`length === 0`) */
+    isEmpty() {
+        return this.length === 0;
     }
-    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;
+    /** Returns true if the range is wrapped (`start` >= `end`) and is not empty */
+    isWrapped() {
+        return this.start >= this.end && !this.isEmpty();
+    }
+    /** Checks if given memory address is within the range */
+    isInRange(address) {
+        if (this.isWrapped()) {
+            return address >= this.start || address < this.end;
         }
-        return table;
+        return address >= this.start && address < this.end;
     }
-    static empty() {
-        return new mask_Mask(BitVec.empty(0));
+    /** 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 memory_range_RESERVED_MEMORY_RANGE = memory_range_MemoryRange.fromStartAndLength(memory_index_tryAsMemoryIndex(0), memory_consts_RESERVED_NUMBER_OF_PAGES * memory_consts_PAGE_SIZE);
 
-;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/args-decoder/argument-type.ts
-var argument_type_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";
-})(argument_type_ArgumentType || (argument_type_ArgumentType = {}));
+;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/memory/page-range.ts
 
-;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/args-decoder/decoders/nibbles-decoder.ts
 
-const MAX_REGISTER_INDEX = registers_NO_OF_REGISTERS - 1;
-const nibbles_decoder_MAX_LENGTH = 4;
-class nibbles_decoder_NibblesDecoder {
-    byte = new Int8Array(1);
-    setByte(byte) {
-        this.byte[0] = byte;
+
+/**
+ * A half-open range of memory pages. Similarly to [`MemoryRange`], can be empty
+ * or wrapped around the memory.
+ */
+class page_range_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 = page_utils_tryAsPageNumber((this.start + this.length) % MAX_NUMBER_OF_PAGES);
     }
-    getHighNibble() {
-        return (this.byte[0] & 0xf0) >>> 4;
+    /**
+     * 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 = memory_utils_getPageNumber(range.start);
+        if (range.isEmpty()) {
+            return new page_range_PageRange(startPage, 0);
+        }
+        // lastIndex is not null because we just ensured that the range is not empty
+        const pageWithLastIndex = memory_utils_getPageNumber(range.lastIndex ?? range.end);
+        const endPage = getNextPageNumber(pageWithLastIndex);
+        if ((startPage === endPage || startPage === pageWithLastIndex) && range.length > memory_consts_PAGE_SIZE) {
+            // full range
+            return new page_range_PageRange(startPage, MAX_NUMBER_OF_PAGES);
+        }
+        const length = startPage < endPage ? endPage - startPage : MAX_NUMBER_OF_PAGES - startPage + endPage;
+        return page_range_PageRange.fromStartAndLength(startPage, length);
     }
-    getLowNibble() {
-        return this.byte[0] & 0x0f;
+    /** 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 page_range_PageRange(start, length);
     }
-    getHighNibbleAsRegisterIndex() {
-        return Math.min(this.getHighNibble(), MAX_REGISTER_INDEX);
+    /** Returns true if the page range is wrapped (`start` >= `end`) and is not empty */
+    isWrapped() {
+        return this.start >= this.end && !this.isEmpty();
     }
-    getLowNibbleAsRegisterIndex() {
-        return Math.min(this.getLowNibble(), MAX_REGISTER_INDEX);
+    /** 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;
     }
-    getHighNibbleAsLength() {
-        return Math.min(this.getHighNibble(), nibbles_decoder_MAX_LENGTH);
+    /** Checks if a range is empty (`length === 0`) */
+    isEmpty() {
+        return this.length === 0;
     }
-    getLowNibbleAsLength() {
-        return Math.min(this.getLowNibble(), nibbles_decoder_MAX_LENGTH);
+    *[Symbol.iterator]() {
+        if (this.isEmpty()) {
+            return;
+        }
+        const end = this.end;
+        let i = this.start;
+        do {
+            yield i;
+            i = getNextPageNumber(i);
+        } while (i !== end);
     }
 }
 
-;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/args-decoder/args-decoder.ts
-
-
-
+;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/memory/pages/memory-page.ts
 
-const IMMEDIATE_AND_OFFSET_MAX_LENGTH = 4;
-class args_decoder_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;
-            }
-        }
+class MemoryPage {
+    start;
+    constructor(pageNumber) {
+        this.start = getStartPageIndexFromPageNumber(pageNumber);
     }
 }
 
-;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/args-decoder/args-decoding-results.ts
-
-
-
-const ARGUMENT_TYPE_LENGTH = Object.keys(argument_type_ArgumentType).length / 2;
-const args_decoding_results_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;
-};
-
-;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/instruction.ts
-var instruction_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 || (instruction_Instruction = {}));
-const HIGHEST_INSTRUCTION_NUMBER = instruction_Instruction.MIN_U;
-
-;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/args-decoder/instruction-argument-type-map.ts
-
-
-const instruction_argument_type_map_instructionArgumentTypeMap = (() => {
-    const instructionArgumentTypeMap = new Array(HIGHEST_INSTRUCTION_NUMBER + 1);
-    instructionArgumentTypeMap[instruction_Instruction.TRAP] = argument_type_ArgumentType.NO_ARGUMENTS;
-    instructionArgumentTypeMap[instruction_Instruction.FALLTHROUGH] = argument_type_ArgumentType.NO_ARGUMENTS;
-    instructionArgumentTypeMap[instruction_Instruction.ECALLI] = argument_type_ArgumentType.ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.LOAD_IMM_64] = argument_type_ArgumentType.ONE_REGISTER_ONE_EXTENDED_WIDTH_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.STORE_IMM_U8] = argument_type_ArgumentType.TWO_IMMEDIATES;
-    instructionArgumentTypeMap[instruction_Instruction.STORE_IMM_U16] = argument_type_ArgumentType.TWO_IMMEDIATES;
-    instructionArgumentTypeMap[instruction_Instruction.STORE_IMM_U32] = argument_type_ArgumentType.TWO_IMMEDIATES;
-    instructionArgumentTypeMap[instruction_Instruction.STORE_IMM_U64] = argument_type_ArgumentType.TWO_IMMEDIATES;
-    instructionArgumentTypeMap[instruction_Instruction.JUMP] = argument_type_ArgumentType.ONE_OFFSET;
-    instructionArgumentTypeMap[instruction_Instruction.JUMP_IND] = argument_type_ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.LOAD_IMM] = argument_type_ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.LOAD_U8] = argument_type_ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.LOAD_I8] = argument_type_ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.LOAD_U16] = argument_type_ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.LOAD_I16] = argument_type_ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.LOAD_U32] = argument_type_ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.LOAD_I32] = argument_type_ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.LOAD_U64] = argument_type_ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.STORE_U8] = argument_type_ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.STORE_U16] = argument_type_ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.STORE_U32] = argument_type_ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.STORE_U64] = argument_type_ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.STORE_IMM_IND_U8] = argument_type_ArgumentType.ONE_REGISTER_TWO_IMMEDIATES;
-    instructionArgumentTypeMap[instruction_Instruction.STORE_IMM_IND_U16] = argument_type_ArgumentType.ONE_REGISTER_TWO_IMMEDIATES;
-    instructionArgumentTypeMap[instruction_Instruction.STORE_IMM_IND_U32] = argument_type_ArgumentType.ONE_REGISTER_TWO_IMMEDIATES;
-    instructionArgumentTypeMap[instruction_Instruction.STORE_IMM_IND_U64] = argument_type_ArgumentType.ONE_REGISTER_TWO_IMMEDIATES;
-    instructionArgumentTypeMap[instruction_Instruction.LOAD_IMM_JUMP] = argument_type_ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
-    instructionArgumentTypeMap[instruction_Instruction.BRANCH_EQ_IMM] = argument_type_ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
-    instructionArgumentTypeMap[instruction_Instruction.BRANCH_NE_IMM] = argument_type_ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
-    instructionArgumentTypeMap[instruction_Instruction.BRANCH_LT_U_IMM] = argument_type_ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
-    instructionArgumentTypeMap[instruction_Instruction.BRANCH_LE_U_IMM] = argument_type_ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
-    instructionArgumentTypeMap[instruction_Instruction.BRANCH_GE_U_IMM] = argument_type_ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
-    instructionArgumentTypeMap[instruction_Instruction.BRANCH_GT_U_IMM] = argument_type_ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
-    instructionArgumentTypeMap[instruction_Instruction.BRANCH_LT_S_IMM] = argument_type_ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
-    instructionArgumentTypeMap[instruction_Instruction.BRANCH_LE_S_IMM] = argument_type_ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
-    instructionArgumentTypeMap[instruction_Instruction.BRANCH_GE_S_IMM] = argument_type_ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
-    instructionArgumentTypeMap[instruction_Instruction.BRANCH_GT_S_IMM] = argument_type_ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
-    instructionArgumentTypeMap[instruction_Instruction.MOVE_REG] = argument_type_ArgumentType.TWO_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.SBRK] = argument_type_ArgumentType.TWO_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.COUNT_SET_BITS_64] = argument_type_ArgumentType.TWO_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.COUNT_SET_BITS_32] = argument_type_ArgumentType.TWO_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.LEADING_ZERO_BITS_64] = argument_type_ArgumentType.TWO_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.LEADING_ZERO_BITS_32] = argument_type_ArgumentType.TWO_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.TRAILING_ZERO_BITS_64] = argument_type_ArgumentType.TWO_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.TRAILING_ZERO_BITS_32] = argument_type_ArgumentType.TWO_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.SIGN_EXTEND_8] = argument_type_ArgumentType.TWO_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.SIGN_EXTEND_16] = argument_type_ArgumentType.TWO_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.ZERO_EXTEND_16] = argument_type_ArgumentType.TWO_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.REVERSE_BYTES] = argument_type_ArgumentType.TWO_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.STORE_IND_U8] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.STORE_IND_U16] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.STORE_IND_U32] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.STORE_IND_U64] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.LOAD_IND_U8] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.LOAD_IND_I8] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.LOAD_IND_U16] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.LOAD_IND_I16] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.LOAD_IND_U32] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.LOAD_IND_I32] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.LOAD_IND_U64] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.ADD_IMM_32] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.ADD_IMM_64] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.AND_IMM] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.XOR_IMM] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.OR_IMM] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.MUL_IMM_32] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.MUL_IMM_64] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.SET_LT_U_IMM] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.SET_LT_S_IMM] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.SHLO_L_IMM_32] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.SHLO_R_IMM_32] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.SHAR_R_IMM_32] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.NEG_ADD_IMM_32] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.SHLO_L_IMM_64] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.SHLO_R_IMM_64] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.SHAR_R_IMM_64] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.NEG_ADD_IMM_64] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.SET_GT_U_IMM] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.SET_GT_S_IMM] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.SHLO_L_IMM_ALT_32] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.SHLO_R_IMM_ALT_32] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.SHAR_R_IMM_ALT_32] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.SHLO_L_IMM_ALT_64] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.SHLO_R_IMM_ALT_64] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.SHAR_R_IMM_ALT_64] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.CMOV_IZ_IMM] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.CMOV_NZ_IMM] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.ROT_R_64_IMM] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.ROT_R_64_IMM_ALT] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.ROT_R_32_IMM] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.ROT_R_32_IMM_ALT] = argument_type_ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-    instructionArgumentTypeMap[instruction_Instruction.BRANCH_EQ] = argument_type_ArgumentType.TWO_REGISTERS_ONE_OFFSET;
-    instructionArgumentTypeMap[instruction_Instruction.BRANCH_NE] = argument_type_ArgumentType.TWO_REGISTERS_ONE_OFFSET;
-    instructionArgumentTypeMap[instruction_Instruction.BRANCH_LT_U] = argument_type_ArgumentType.TWO_REGISTERS_ONE_OFFSET;
-    instructionArgumentTypeMap[instruction_Instruction.BRANCH_LT_S] = argument_type_ArgumentType.TWO_REGISTERS_ONE_OFFSET;
-    instructionArgumentTypeMap[instruction_Instruction.BRANCH_GE_U] = argument_type_ArgumentType.TWO_REGISTERS_ONE_OFFSET;
-    instructionArgumentTypeMap[instruction_Instruction.BRANCH_GE_S] = argument_type_ArgumentType.TWO_REGISTERS_ONE_OFFSET;
-    instructionArgumentTypeMap[instruction_Instruction.LOAD_IMM_JUMP_IND] = argument_type_ArgumentType.TWO_REGISTERS_TWO_IMMEDIATES;
-    instructionArgumentTypeMap[instruction_Instruction.ADD_32] = argument_type_ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.ADD_64] = argument_type_ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.SUB_32] = argument_type_ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.SUB_64] = argument_type_ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.AND] = argument_type_ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.XOR] = argument_type_ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.OR] = argument_type_ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.MUL_32] = argument_type_ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.MUL_64] = argument_type_ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.MUL_UPPER_S_S] = argument_type_ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.MUL_UPPER_U_U] = argument_type_ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.MUL_UPPER_S_U] = argument_type_ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.DIV_U_32] = argument_type_ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.DIV_S_32] = argument_type_ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.REM_U_32] = argument_type_ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.REM_S_32] = argument_type_ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.DIV_U_64] = argument_type_ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.DIV_S_64] = argument_type_ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.REM_U_64] = argument_type_ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.REM_S_64] = argument_type_ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.SET_LT_U] = argument_type_ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.SET_LT_S] = argument_type_ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.SHLO_L_32] = argument_type_ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.SHLO_R_32] = argument_type_ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.SHAR_R_32] = argument_type_ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.SHLO_L_64] = argument_type_ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.SHLO_R_64] = argument_type_ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.SHAR_R_64] = argument_type_ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.CMOV_IZ] = argument_type_ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.CMOV_NZ] = argument_type_ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.ROT_L_64] = argument_type_ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.ROT_L_32] = argument_type_ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.ROT_R_64] = argument_type_ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.ROT_R_32] = argument_type_ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.AND_INV] = argument_type_ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.OR_INV] = argument_type_ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.XNOR] = argument_type_ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.MAX] = argument_type_ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.MAX_U] = argument_type_ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.MIN] = argument_type_ArgumentType.THREE_REGISTERS;
-    instructionArgumentTypeMap[instruction_Instruction.MIN_U] = argument_type_ArgumentType.THREE_REGISTERS;
-    return instructionArgumentTypeMap;
-})();
+;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/memory/pages/readable-page.ts
 
-;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/assemblify.ts
 
 
-const instructionsWithoutArgs = [
-    [instruction_Instruction.TRAP, 1],
-    [instruction_Instruction.FALLTHROUGH, 1],
-];
-const instructionsWithOneImmediate = [[instruction_Instruction.ECALLI, 1]];
-const instructionsWithOneRegisterAndOneExtendedWidthImmediate = [[instruction_Instruction.LOAD_IMM_64, 1]];
-const instructionsWithTwoImmediates = [
-    [instruction_Instruction.STORE_IMM_U8, 1],
-    [instruction_Instruction.STORE_IMM_U16, 1],
-    [instruction_Instruction.STORE_IMM_U32, 1],
-    [instruction_Instruction.STORE_IMM_U64, 1],
-];
-const instructionsWithOneOffset = [[instruction_Instruction.JUMP, 1]];
-const instructionsWithOneRegisterAndOneImmediate = [
-    [instruction_Instruction.JUMP_IND, 1],
-    [instruction_Instruction.LOAD_IMM, 1],
-    [instruction_Instruction.LOAD_U8, 1],
-    [instruction_Instruction.LOAD_I8, 1],
-    [instruction_Instruction.LOAD_U16, 1],
-    [instruction_Instruction.LOAD_I16, 1],
-    [instruction_Instruction.LOAD_U32, 1],
-    [instruction_Instruction.LOAD_I32, 1],
-    [instruction_Instruction.LOAD_U64, 1],
-    [instruction_Instruction.STORE_U8, 1],
-    [instruction_Instruction.STORE_U16, 1],
-    [instruction_Instruction.STORE_U32, 1],
-    [instruction_Instruction.STORE_U64, 1],
-];
-const instructionsWithOneRegisterAndTwoImmediate = [
-    [instruction_Instruction.STORE_IMM_IND_U8, 1],
-    [instruction_Instruction.STORE_IMM_IND_U16, 1],
-    [instruction_Instruction.STORE_IMM_IND_U32, 1],
-    [instruction_Instruction.STORE_IMM_IND_U64, 1],
-];
-const instructionsWithOneRegisterOneImmediateAndOneOffset = [
-    [instruction_Instruction.LOAD_IMM_JUMP, 1],
-    [instruction_Instruction.BRANCH_EQ_IMM, 1],
-    [instruction_Instruction.BRANCH_NE_IMM, 1],
-    [instruction_Instruction.BRANCH_LT_U_IMM, 1],
-    [instruction_Instruction.BRANCH_LE_U_IMM, 1],
-    [instruction_Instruction.BRANCH_GE_U_IMM, 1],
-    [instruction_Instruction.BRANCH_GT_U_IMM, 1],
-    [instruction_Instruction.BRANCH_LT_S_IMM, 1],
-    [instruction_Instruction.BRANCH_LE_S_IMM, 1],
-    [instruction_Instruction.BRANCH_GE_S_IMM, 1],
-    [instruction_Instruction.BRANCH_GT_S_IMM, 1],
-];
-const instructionsWithTwoRegisters = [
-    [instruction_Instruction.MOVE_REG, 1],
-    [instruction_Instruction.SBRK, 1],
-    [instruction_Instruction.COUNT_SET_BITS_64, 1],
-    [instruction_Instruction.COUNT_SET_BITS_32, 1],
-    [instruction_Instruction.LEADING_ZERO_BITS_64, 1],
-    [instruction_Instruction.LEADING_ZERO_BITS_32, 1],
-    [instruction_Instruction.TRAILING_ZERO_BITS_64, 1],
-    [instruction_Instruction.TRAILING_ZERO_BITS_32, 1],
-    [instruction_Instruction.SIGN_EXTEND_8, 1],
-    [instruction_Instruction.SIGN_EXTEND_16, 1],
-    [instruction_Instruction.ZERO_EXTEND_16, 1],
-    [instruction_Instruction.REVERSE_BYTES, 1],
-];
-const instructionsWithTwoRegistersAndOneImmediate = [
-    [instruction_Instruction.STORE_IND_U8, 1],
-    [instruction_Instruction.STORE_IND_U16, 1],
-    [instruction_Instruction.STORE_IND_U32, 1],
-    [instruction_Instruction.STORE_IND_U64, 1],
-    [instruction_Instruction.LOAD_IND_U8, 1],
-    [instruction_Instruction.LOAD_IND_I8, 1],
-    [instruction_Instruction.LOAD_IND_U16, 1],
-    [instruction_Instruction.LOAD_IND_I16, 1],
-    [instruction_Instruction.LOAD_IND_U32, 1],
-    [instruction_Instruction.LOAD_IND_I32, 1],
-    [instruction_Instruction.LOAD_IND_U64, 1],
-    [instruction_Instruction.ADD_IMM_32, 1],
-    [instruction_Instruction.AND_IMM, 1],
-    [instruction_Instruction.XOR_IMM, 1],
-    [instruction_Instruction.OR_IMM, 1],
-    [instruction_Instruction.MUL_IMM_32, 1],
-    [instruction_Instruction.SET_LT_U_IMM, 1],
-    [instruction_Instruction.SET_LT_S_IMM, 1],
-    [instruction_Instruction.SHLO_L_IMM_32, 1],
-    [instruction_Instruction.SHLO_R_IMM_32, 1],
-    [instruction_Instruction.SHAR_R_IMM_32, 1],
-    [instruction_Instruction.NEG_ADD_IMM_32, 1],
-    [instruction_Instruction.SET_GT_U_IMM, 1],
-    [instruction_Instruction.SET_GT_S_IMM, 1],
-    [instruction_Instruction.SHLO_L_IMM_ALT_32, 1],
-    [instruction_Instruction.SHLO_R_IMM_ALT_32, 1],
-    [instruction_Instruction.SHAR_R_IMM_ALT_32, 1],
-    [instruction_Instruction.CMOV_IZ_IMM, 1],
-    [instruction_Instruction.CMOV_NZ_IMM, 1],
-    [instruction_Instruction.ADD_IMM_64, 1],
-    [instruction_Instruction.MUL_IMM_64, 1],
-    [instruction_Instruction.SHLO_L_IMM_64, 1],
-    [instruction_Instruction.SHLO_R_IMM_64, 1],
-    [instruction_Instruction.SHAR_R_IMM_64, 1],
-    [instruction_Instruction.NEG_ADD_IMM_64, 1],
-    [instruction_Instruction.SHLO_L_IMM_ALT_64, 1],
-    [instruction_Instruction.SHLO_R_IMM_ALT_64, 1],
-    [instruction_Instruction.SHAR_R_IMM_ALT_64, 1],
-    [instruction_Instruction.ROT_R_64_IMM, 1],
-    [instruction_Instruction.ROT_R_64_IMM_ALT, 1],
-    [instruction_Instruction.ROT_R_32_IMM, 1],
-    [instruction_Instruction.ROT_R_32_IMM_ALT, 1],
-];
-const instructionsWithTwoRegistersAndOneOffset = [
-    [instruction_Instruction.BRANCH_EQ, 1],
-    [instruction_Instruction.BRANCH_NE, 1],
-    [instruction_Instruction.BRANCH_LT_U, 1],
-    [instruction_Instruction.BRANCH_LT_S, 1],
-    [instruction_Instruction.BRANCH_GE_U, 1],
-    [instruction_Instruction.BRANCH_GE_S, 1],
-];
-const instructionWithTwoRegistersAndTwoImmediates = [[instruction_Instruction.LOAD_IMM_JUMP_IND, 1]];
-const instructionsWithThreeRegisters = [
-    [instruction_Instruction.ADD_32, 1],
-    [instruction_Instruction.SUB_32, 1],
-    [instruction_Instruction.MUL_32, 1],
-    [instruction_Instruction.DIV_U_32, 1],
-    [instruction_Instruction.DIV_S_32, 1],
-    [instruction_Instruction.REM_U_32, 1],
-    [instruction_Instruction.REM_S_32, 1],
-    [instruction_Instruction.SHLO_L_32, 1],
-    [instruction_Instruction.SHLO_R_32, 1],
-    [instruction_Instruction.SHAR_R_32, 1],
-    [instruction_Instruction.ADD_64, 1],
-    [instruction_Instruction.SUB_64, 1],
-    [instruction_Instruction.MUL_64, 1],
-    [instruction_Instruction.DIV_U_64, 1],
-    [instruction_Instruction.DIV_S_64, 1],
-    [instruction_Instruction.REM_U_64, 1],
-    [instruction_Instruction.REM_S_64, 1],
-    [instruction_Instruction.SHLO_L_64, 1],
-    [instruction_Instruction.SHLO_R_64, 1],
-    [instruction_Instruction.SHAR_R_64, 1],
-    [instruction_Instruction.AND, 1],
-    [instruction_Instruction.XOR, 1],
-    [instruction_Instruction.OR, 1],
-    [instruction_Instruction.MUL_UPPER_S_S, 1],
-    [instruction_Instruction.MUL_UPPER_U_U, 1],
-    [instruction_Instruction.MUL_UPPER_S_U, 1],
-    [instruction_Instruction.SET_LT_U, 1],
-    [instruction_Instruction.SET_LT_S, 1],
-    [instruction_Instruction.CMOV_IZ, 1],
-    [instruction_Instruction.CMOV_NZ, 1],
-    [instruction_Instruction.ROT_L_64, 1],
-    [instruction_Instruction.ROT_L_32, 1],
-    [instruction_Instruction.ROT_R_64, 1],
-    [instruction_Instruction.ROT_R_32, 1],
-    [instruction_Instruction.AND_INV, 1],
-    [instruction_Instruction.OR_INV, 1],
-    [instruction_Instruction.XNOR, 1],
-    [instruction_Instruction.MAX, 1],
-    [instruction_Instruction.MAX_U, 1],
-    [instruction_Instruction.MIN, 1],
-    [instruction_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_assemblify(program, mask) {
-    return program.reduce((acc, byte, index) => {
-        if (mask.isInstruction(index)) {
-            acc.push([Instruction[byte]]);
+
+class readable_page_ReadablePage extends MemoryPage {
+    data;
+    constructor(pageNumber, data) {
+        super(pageNumber);
+        this.data = data;
+    }
+    loadInto(result, startIndex, length) {
+        const endIndex = startIndex + length;
+        if (endIndex > memory_consts_PAGE_SIZE) {
+            return result_Result.error(errors_PageFault.fromMemoryIndex(this.start + memory_consts_PAGE_SIZE), () => `Page fault: read beyond page boundary at ${this.start + memory_consts_PAGE_SIZE}`);
         }
-        else {
-            acc[acc.length - 1].push(byte);
+        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_Result.ok(result_OK);
+    }
+    storeFrom(_address, _data) {
+        return result_Result.error(errors_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;
+    }
+}
+
+;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/memory/pages/writeable-page.ts
+
+
+
+
+class writeable_page_WriteablePage extends MemoryPage {
+    buffer;
+    view;
+    constructor(pageNumber, initialData) {
+        super(pageNumber);
+        const dataLength = initialData?.length ?? 0;
+        const initialPageLength = Math.min(memory_consts_PAGE_SIZE, Math.max(dataLength, MIN_ALLOCATION_LENGTH));
+        this.buffer = new ArrayBuffer(initialPageLength, { maxByteLength: memory_consts_PAGE_SIZE });
+        this.view = new Uint8Array(this.buffer);
+        if (initialData !== undefined) {
+            this.view.set(initialData);
+        }
+    }
+    loadInto(result, startIndex, length) {
+        const endIndex = startIndex + length;
+        if (endIndex > memory_consts_PAGE_SIZE) {
+            return result_Result.error(errors_PageFault.fromMemoryIndex(this.start + memory_consts_PAGE_SIZE), () => `Page fault: read beyond page boundary at ${this.start + memory_consts_PAGE_SIZE}`);
+        }
+        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_Result.ok(result_OK);
+    }
+    storeFrom(startIndex, bytes) {
+        if (this.buffer.byteLength < startIndex + bytes.length && this.buffer.byteLength < memory_consts_PAGE_SIZE) {
+            const newLength = Math.min(memory_consts_PAGE_SIZE, Math.max(MIN_ALLOCATION_LENGTH, startIndex + bytes.length));
+            this.buffer.resize(newLength);
+        }
+        this.view.set(bytes, startIndex);
+        return result_Result.ok(result_OK);
+    }
+    setData(pageIndex, data) {
+        if (this.buffer.byteLength < pageIndex + data.length && this.buffer.byteLength < memory_consts_PAGE_SIZE) {
+            const newLength = Math.min(memory_consts_PAGE_SIZE, Math.max(MIN_ALLOCATION_LENGTH, pageIndex + data.length));
+            this.buffer.resize(newLength);
         }
-        return acc;
-    }, []);
+        this.view.set(data, pageIndex);
+    }
+    isWriteable() {
+        return true;
+    }
+    getPageDump() {
+        return this.view;
+    }
 }
 
-;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/basic-blocks/is-termination-instruction.ts
+;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/memory/pages/index.ts
 
-const is_termination_instruction_terminationInstructions = (() => {
-    const terminationInstructions = new Array(HIGHEST_INSTRUCTION_NUMBER + 1);
-    terminationInstructions.fill(false);
-    terminationInstructions[instruction_Instruction.TRAP] = true;
-    terminationInstructions[instruction_Instruction.FALLTHROUGH] = true;
-    terminationInstructions[instruction_Instruction.JUMP] = true;
-    terminationInstructions[instruction_Instruction.JUMP_IND] = true;
-    terminationInstructions[instruction_Instruction.LOAD_IMM_JUMP] = true;
-    terminationInstructions[instruction_Instruction.LOAD_IMM_JUMP_IND] = true;
-    terminationInstructions[instruction_Instruction.BRANCH_EQ] = true;
-    terminationInstructions[instruction_Instruction.BRANCH_NE] = true;
-    terminationInstructions[instruction_Instruction.BRANCH_GE_U] = true;
-    terminationInstructions[instruction_Instruction.BRANCH_GE_S] = true;
-    terminationInstructions[instruction_Instruction.BRANCH_LT_U] = true;
-    terminationInstructions[instruction_Instruction.BRANCH_LT_S] = true;
-    terminationInstructions[instruction_Instruction.BRANCH_EQ_IMM] = true;
-    terminationInstructions[instruction_Instruction.BRANCH_NE_IMM] = true;
-    terminationInstructions[instruction_Instruction.BRANCH_LT_U_IMM] = true;
-    terminationInstructions[instruction_Instruction.BRANCH_LT_S_IMM] = true;
-    terminationInstructions[instruction_Instruction.BRANCH_LE_U_IMM] = true;
-    terminationInstructions[instruction_Instruction.BRANCH_LE_S_IMM] = true;
-    terminationInstructions[instruction_Instruction.BRANCH_GE_U_IMM] = true;
-    terminationInstructions[instruction_Instruction.BRANCH_GE_S_IMM] = true;
-    terminationInstructions[instruction_Instruction.BRANCH_GT_U_IMM] = true;
-    terminationInstructions[instruction_Instruction.BRANCH_GT_S_IMM] = true;
-    return terminationInstructions;
-})();
 
-;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/basic-blocks/basic-blocks.ts
 
-class basic_blocks_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));
+;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/memory/memory.ts
+
+
+
+
+
+
+
+
+
+
+
+
+var AccessType;
+(function (AccessType) {
+    AccessType[AccessType["READ"] = 0] = "READ";
+    AccessType[AccessType["WRITE"] = 1] = "WRITE";
+})(AccessType || (AccessType = {}));
+const memory_logger = Logger.new(import.meta.filename, "pvm:mem");
+class memory_Memory {
+    sbrkIndex;
+    virtualSbrkIndex;
+    endHeapIndex;
+    memory;
+    static fromInitialMemory(initialMemoryState) {
+        return new memory_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.ok(OK);
+        }
+        memory_logger.insane `MEM[${address}] <- ${BytesBlob.blobFrom(bytes)}`;
+        const pagesResult = this.getPages(address, bytes.length, AccessType.WRITE);
+        if (pagesResult.isError) {
+            return Result.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);
+            const bytesToWrite = Math.min(PAGE_SIZE - pageStartIndex, bytesLeft);
+            const sourceStartIndex = currentPosition - address;
+            const source = bytes.subarray(sourceStartIndex, sourceStartIndex + bytesToWrite);
+            page.storeFrom(pageStartIndex, source);
+            currentPosition += bytesToWrite;
+            bytesLeft -= bytesToWrite;
+        }
+        return Result.ok(OK);
+    }
+    getPages(startAddress, length, accessType) {
+        if (length === 0) {
+            return Result.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.error(PageFault.fromPageNumber(pageNumber, true), () => `Page fault: attempted to access reserved page ${pageNumber}`);
+            }
+            const page = this.memory.get(pageNumber);
+            if (page === undefined) {
+                return Result.error(PageFault.fromPageNumber(pageNumber), () => `Page fault: page ${pageNumber} not allocated`);
+            }
+            if (accessType === AccessType.WRITE && !page.isWriteable()) {
+                return Result.error(PageFault.fromPageNumber(pageNumber, true), () => `Page fault: attempted to write to read-only page ${pageNumber}`);
             }
+            pages.push(page);
         }
+        return Result.ok(pages);
     }
-    isBeginningOfBasicBlock(index) {
-        return this.basicBlocks.has(index);
+    /**
+     * 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.ok(OK);
+        }
+        const pagesResult = this.getPages(startAddress, result.length, AccessType.READ);
+        if (pagesResult.isError) {
+            return Result.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);
+            const bytesToRead = Math.min(PAGE_SIZE - pageStartIndex, bytesLeft);
+            const destinationStartIndex = currentPosition - startAddress;
+            const destination = result.subarray(destinationStartIndex);
+            page.loadInto(destination, pageStartIndex, bytesToRead);
+            currentPosition += bytesToRead;
+            bytesLeft -= bytesToRead;
+        }
+        memory_logger.insane `MEM[${startAddress}] => ${BytesBlob.blobFrom(result)}`;
+        return Result.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(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;
+        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();
     }
 }
 
-;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/basic-blocks/index.ts
+;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/memory/memory-builder.ts
 
 
-;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/gas.ts
 
 
-/** Create a new gas counter instance depending on the gas value. */
-function gas_gasCounter(gas) {
-    return new GasCounterU64(tryAsU64(gas));
-}
-class GasCounterU64 {
-    gas;
-    initialGas;
-    constructor(gas) {
-        this.gas = gas;
-        this.initialGas = tryAsGas(gas);
+
+
+
+
+
+
+class memory_builder_MemoryBuilder {
+    initialMemory = new Map();
+    isFinalized = false;
+    ensureNotFinalized() {
+        if (this.isFinalized) {
+            throw new FinalizedBuilderModification();
+        }
     }
-    set(g) {
-        this.gas = tryAsU64(g);
+    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 === 0} start needs to be a multiple of page size (${PAGE_SIZE})`;
+        check `${end % PAGE_SIZE === 0} end needs to be a multiple of page size (${PAGE_SIZE})`;
+        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, (i + 1) * PAGE_SIZE);
+            const page = new ReadablePage(pageNumber, dataChunk);
+            this.initialMemory.set(pageNumber, page);
+        }
+        return this;
     }
-    get() {
-        return tryAsGas(this.gas);
+    /**
+     * 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 === 0} start needs to be a multiple of page size (${PAGE_SIZE})`;
+        check `${end % PAGE_SIZE === 0} end needs to be a multiple of page size (${PAGE_SIZE})`;
+        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, (i + 1) * PAGE_SIZE);
+            const page = new WriteablePage(pageNumber, dataChunk);
+            this.initialMemory.set(pageNumber, page);
+        }
+        return this;
     }
-    sub(g) {
-        const result = this.gas - tryAsU64(g);
-        if (result >= 0n) {
-            this.gas = tryAsU64(result);
-            return false;
+    /**
+     * 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;
+        const remainingSpaceOnPage = PAGE_SIZE - 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();
         }
-        this.gas = tryAsU64(0n);
-        return true;
+        const startPageIndex = tryAsPageIndex(start - page.start);
+        page.setData(startPageIndex, data);
+        return this;
     }
-    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;
+    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();
+            }
         }
-        return tryAsGas(gasConsumed);
+        const memory = Memory.fromInitialMemory({
+            memory: this.initialMemory,
+            sbrkIndex: tryAsSbrkIndex(startHeapIndex),
+            endHeapIndex,
+        });
+        this.isFinalized = true;
+        return memory;
     }
 }
 
-;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/instruction-gas-map.ts
+;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/memory/index.ts
+
 
 
-const instruction_gas_map_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;
-})();
 
 ;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/ops/math-utils.ts
 
@@ -18522,6 +18388,92 @@ class load_ops_LoadOps {
     }
 }
 
+;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/registers.ts
+
+
+const REGISTER_SIZE_SHIFT = 3; // x << 3 === x * 8
+const tryAsRegisterIndex = (index) => {
+    check `${index >= 0 && index < NO_OF_REGISTERS} Incorrect register index: ${index}!`;
+    return asOpaqueType(index);
+};
+class registers_Registers {
+    bytes;
+    asSigned;
+    asUnsigned;
+    constructor(bytes = safeAllocUint8Array(NO_OF_REGISTERS << REGISTER_SIZE_SHIFT)) {
+        this.bytes = bytes;
+        check `${bytes.length === NO_OF_REGISTERS << REGISTER_SIZE_SHIFT} Invalid size of registers array.`;
+        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 << REGISTER_SIZE_SHIFT} Invalid size of registers array.`;
+        return new registers_Registers(bytes);
+    }
+    getBytesAsLittleEndian(index, len) {
+        const offset = index << REGISTER_SIZE_SHIFT;
+        return this.bytes.subarray(offset, offset + len);
+    }
+    copyFrom(regs) {
+        const array = regs instanceof BigUint64Array ? regs : regs.asUnsigned;
+        this.asUnsigned.set(array);
+    }
+    reset() {
+        for (let i = 0; i < NO_OF_REGISTERS; i++) {
+            this.asUnsigned[i] = 0n;
+        }
+    }
+    getLowerU32(registerIndex) {
+        return Number(this.asUnsigned[registerIndex] & 0xffffffffn);
+    }
+    getLowerI32(registerIndex) {
+        return Number(this.getLowerU32(registerIndex)) >> 0;
+    }
+    setU32(registerIndex, value) {
+        this.asUnsigned[registerIndex] = registers_signExtend32To64(value);
+    }
+    setI32(registerIndex, value) {
+        this.asSigned[registerIndex] = registers_signExtend32To64(value);
+    }
+    getU64(registerIndex) {
+        return this.asUnsigned[registerIndex];
+    }
+    getI64(registerIndex) {
+        return this.asSigned[registerIndex];
+    }
+    setU64(registerIndex, value) {
+        this.asUnsigned[registerIndex] = value;
+    }
+    setI64(registerIndex, value) {
+        this.asSigned[registerIndex] = value;
+    }
+    getAllU64() {
+        return this.asUnsigned;
+    }
+}
+function registers_signExtend32To64(value) {
+    // Convert to BigInt if the value is a number
+    const bigValue = typeof value === "number" ? BigInt(value) : value;
+    // Ensure the value is treated as a 32-bit integer
+    const mask32 = BigInt(0xffffffff);
+    const signBit = BigInt(0x80000000);
+    const maskedValue = bigValue & mask32;
+    // Check the sign bit and extend the sign if necessary
+    if ((maskedValue & signBit) !== BigInt(0)) {
+        // If the sign bit is set, extend with ones
+        return maskedValue | ~mask32;
+    }
+    // If the sign bit is not set, return as is
+    return maskedValue;
+}
+
 ;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/ops/math-ops.ts
 
 
@@ -19517,6 +19469,63 @@ class two_regs_two_imms_dispatcher_TwoRegsTwoImmsDispatcher {
 
 
 
+;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/program.ts
+
+
+
+
+
+class program_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_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_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 };
+}
+
 ;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/program-decoder/jump-table.ts
 
 class jump_table_JumpTable {
@@ -19709,8 +19718,8 @@ class interpreter_Interpreter {
         this.oneImmDispatcher = new OneImmDispatcher(hostCallOps);
         this.oneRegOneExtImmDispatcher = new OneRegOneExtImmDispatcher(loadOps);
     }
-    resetJam(program, args, pc, gas) {
-        const p = Program.fromSpi(program, args, true);
+    resetJam(program, args, pc, gas, hasMetadata = true) {
+        const p = Program.fromSpi(program, args, hasMetadata);
         this.resetGeneric(p.code, pc, gas, p.registers, p.memory);
     }
     resetGeneric(rawProgram, pc, gas, maybeRegisters, maybeMemory) {
@@ -19897,6 +19906,9 @@ class DebuggerAdapter {
     constructor(useSbrkGas = false) {
         this.pvm = new Interpreter({ useSbrkGas });
     }
+    resetJAM(jamProgram, pc, gas, args, hasMetadata = false) {
+        this.pvm.resetJam(jamProgram, args, pc, tryAsGas(gas), hasMetadata);
+    }
     resetGeneric(rawProgram, flatRegisters, initialGas) {
         this.pvm.resetGeneric(rawProgram, 0, tryAsGas(initialGas), new Registers(flatRegisters));
     }
@@ -19941,7 +19953,7 @@ class DebuggerAdapter {
         return true;
     }
     getRegisters() {
-        return this.pvm.registers.getAllU64();
+        return this.pvm.registers.getAllEncoded();
     }
     setRegisters(registers) {
         this.pvm.registers.copyFrom(new Registers(registers));
@@ -19960,6 +19972,11 @@ class DebuggerAdapter {
     }
 }
 
+;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/program-decoder/index.ts
+
+
+
+
 ;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/index.ts
 
 
@@ -19967,6 +19984,11 @@ class DebuggerAdapter {
 
 
 
+
+
+
+
+
 ;// CONCATENATED MODULE: ./bin/test-runner/w3f/pvm.ts