@typeberry/lib 0.2.0-41490e3 → 0.2.0-5746fdc

package/index.d.ts

@@ -1467,8 +1467,8 @@ declare class Decoder {
   /**
    * Create a new [`Decoder`] instance given a raw array of bytes as a source.
    */
-  static fromBlob(source: Uint8Array) {
-    return new Decoder(source);
+  static fromBlob(source: Uint8Array, context?: unknown) {
+    return new Decoder(source, undefined, context);
   }
 
   /**
@@ -1818,7 +1818,7 @@ declare class Decoder {
   private ensureHasBytes(bytes: number) {
     check`${bytes >= 0} Negative number of bytes given.`;
     if (this.offset + bytes > this.source.length) {
-      throw new Error(
+      throw new EndOfDataError(
         `Attempting to decode more data than there is left. Need ${bytes}, left: ${this.source.length - this.offset}.`,
       );
     }
@@ -1837,6 +1837,8 @@ declare function decodeVariableLengthExtraBytes(firstByte: number) {
   return 0;
 }
 
+declare class EndOfDataError extends Error {}
+
 /** Hint for how big the encoded object will be. */
 type SizeHint = {
   /** Number of bytes in the encoding. */
@@ -2879,6 +2881,15 @@ declare namespace codec$1 {
     };
   })();
 
+  /** Zero-size `void` value. */
+  export const nothing = Descriptor.new<void>(
+    "void",
+    { bytes: 0, isExact: true },
+    (_e, _v) => {},
+    (_d) => {},
+    (_s) => {},
+  );
+
   /** Variable-length U32. */
   export const varU32 = Descriptor.new<U32>(
     "var_u32",
@@ -3346,6 +3357,9 @@ declare function forEachDescriptor<T>(
       try {
         f(k, descriptors[k]);
       } catch (e) {
+        if (e instanceof EndOfDataError) {
+          throw new EndOfDataError(`${key}: ${e}`);
+        }
         throw new Error(`${key}: ${e}`);
       }
     }
@@ -3469,6 +3483,8 @@ type index$q_DescriptorRecord<T> = DescriptorRecord<T>;
 type index$q_Encode<T> = Encode<T>;
 type index$q_Encoder = Encoder;
 declare const index$q_Encoder: typeof Encoder;
+type index$q_EndOfDataError = EndOfDataError;
+declare const index$q_EndOfDataError: typeof EndOfDataError;
 type index$q_LengthRange = LengthRange;
 declare const index$q_MASKS: typeof MASKS;
 declare const index$q_MAX_LENGTH: typeof MAX_LENGTH;
@@ -3497,7 +3513,7 @@ declare const index$q_sequenceViewVarLen: typeof sequenceViewVarLen;
 declare const index$q_tryAsExactBytes: typeof tryAsExactBytes;
 declare const index$q_validateLength: typeof validateLength;
 declare namespace index$q {
-  export { index$q_DEFAULT_START_LENGTH as DEFAULT_START_LENGTH, index$q_Decoder as Decoder, index$q_Descriptor as Descriptor, index$q_Encoder as Encoder, index$q_MASKS as MASKS, index$q_MAX_LENGTH as MAX_LENGTH, index$q_ObjectView as ObjectView, index$q_SequenceView as SequenceView, index$q_TYPICAL_DICTIONARY_LENGTH as TYPICAL_DICTIONARY_LENGTH, index$q_TYPICAL_SEQUENCE_LENGTH as TYPICAL_SEQUENCE_LENGTH, index$q_ViewField as ViewField, index$q_addSizeHints as addSizeHints, codec$1 as codec, index$q_decodeVariableLengthExtraBytes as decodeVariableLengthExtraBytes, index$q_exactHint as exactHint, index$q_forEachDescriptor as forEachDescriptor, index$q_hasUniqueView as hasUniqueView, index$q_objectView as objectView, index$q_readonlyArray as readonlyArray, index$q_sequenceViewFixLen as sequenceViewFixLen, index$q_sequenceViewVarLen as sequenceViewVarLen, index$q_tryAsExactBytes as tryAsExactBytes, index$q_validateLength as validateLength };
+  export { index$q_DEFAULT_START_LENGTH as DEFAULT_START_LENGTH, index$q_Decoder as Decoder, index$q_Descriptor as Descriptor, index$q_Encoder as Encoder, index$q_EndOfDataError as EndOfDataError, index$q_MASKS as MASKS, index$q_MAX_LENGTH as MAX_LENGTH, index$q_ObjectView as ObjectView, index$q_SequenceView as SequenceView, index$q_TYPICAL_DICTIONARY_LENGTH as TYPICAL_DICTIONARY_LENGTH, index$q_TYPICAL_SEQUENCE_LENGTH as TYPICAL_SEQUENCE_LENGTH, index$q_ViewField as ViewField, index$q_addSizeHints as addSizeHints, codec$1 as codec, index$q_decodeVariableLengthExtraBytes as decodeVariableLengthExtraBytes, index$q_exactHint as exactHint, index$q_forEachDescriptor as forEachDescriptor, index$q_hasUniqueView as hasUniqueView, index$q_objectView as objectView, index$q_readonlyArray as readonlyArray, index$q_sequenceViewFixLen as sequenceViewFixLen, index$q_sequenceViewVarLen as sequenceViewVarLen, index$q_tryAsExactBytes as tryAsExactBytes, index$q_validateLength as validateLength };
   export type { index$q_ClassConstructor as ClassConstructor, index$q_Codec as Codec, index$q_CodecRecord as CodecRecord, index$q_CodecWithView as CodecWithView, index$q_Decode as Decode, index$q_DescribedBy as DescribedBy, index$q_DescriptorRecord as DescriptorRecord, index$q_Encode as Encode, index$q_LengthRange as LengthRange, index$q_OptionalRecord as OptionalRecord, Options$1 as Options, index$q_PropertyKeys as PropertyKeys, index$q_SimpleDescriptorRecord as SimpleDescriptorRecord, index$q_SizeHint as SizeHint, index$q_ViewOf as ViewOf };
 }
 
@@ -4263,7 +4279,7 @@ declare class SortedArray<V> implements ImmutableSortedArray<V> {
     };
   }
 
-  /** Create a new SortedSet from two sorted collections. */
+  /** Create a new SortedArray from two sorted collections. */
   static fromTwoSortedCollections<V>(first: ImmutableSortedArray<V>, second: ImmutableSortedArray<V>) {
     check`${first.comparator === second.comparator} Cannot merge arrays if they do not use the same comparator`;
     const comparator = first.comparator;
@@ -5070,29 +5086,6 @@ declare const fullChainSpec = new ChainSpec({
   maxLookupAnchorAge: tryAsU32(14_400),
 });
 
-/**
- * Configuration object for typeberry workers.
- */
-declare class WorkerConfig {
-  /**
-   * Since we loose prototypes when transferring the context,
-   * this function is re-initializing proper types.
-   *
-   * TODO [ToDr] instead of doing this hack, we might prefer to pass data
-   * between workers using JAM codec maybe?
-   */
-  static reInit(config: unknown) {
-    const { chainSpec, dbPath, omitSealVerification } = config as WorkerConfig;
-    return new WorkerConfig(new ChainSpec(chainSpec), dbPath, omitSealVerification);
-  }
-
-  constructor(
-    public readonly chainSpec: ChainSpec,
-    public readonly dbPath: string,
-    public readonly omitSealVerification: boolean = false,
-  ) {}
-}
-
 /** Peer id. */
 type PeerId = Opaque<string, "peerId">;
 
@@ -5124,6 +5117,17 @@ declare class Bootnode implements PeerAddress {
   }
 }
 
+/** Implemented PVM Backends names in THE SAME ORDER as enum. */
+declare const PvmBackendNames = ["built-in", "ananas"];
+
+/** Implemented PVM Backends to choose from. */
+declare enum PvmBackend {
+  /** Built-in aka. Typeberry 🫐 interpreter. */
+  BuiltIn = 0,
+  /** Ananas 🍍 interpreter. */
+  Ananas = 1,
+}
+
 type index$m_Bootnode = Bootnode;
 declare const index$m_Bootnode: typeof Bootnode;
 type index$m_ChainSpec = ChainSpec;
@@ -5135,12 +5139,13 @@ declare const index$m_EST_VALIDATORS: typeof EST_VALIDATORS;
 declare const index$m_EST_VALIDATORS_SUPER_MAJORITY: typeof EST_VALIDATORS_SUPER_MAJORITY;
 type index$m_PeerAddress = PeerAddress;
 type index$m_PeerId = PeerId;
-type index$m_WorkerConfig = WorkerConfig;
-declare const index$m_WorkerConfig: typeof WorkerConfig;
+type index$m_PvmBackend = PvmBackend;
+declare const index$m_PvmBackend: typeof PvmBackend;
+declare const index$m_PvmBackendNames: typeof PvmBackendNames;
 declare const index$m_fullChainSpec: typeof fullChainSpec;
 declare const index$m_tinyChainSpec: typeof tinyChainSpec;
 declare namespace index$m {
-  export { index$m_Bootnode as Bootnode, index$m_ChainSpec as ChainSpec, index$m_EC_SEGMENT_SIZE as EC_SEGMENT_SIZE, index$m_EST_CORES as EST_CORES, index$m_EST_EPOCH_LENGTH as EST_EPOCH_LENGTH, index$m_EST_VALIDATORS as EST_VALIDATORS, index$m_EST_VALIDATORS_SUPER_MAJORITY as EST_VALIDATORS_SUPER_MAJORITY, index$m_WorkerConfig as WorkerConfig, index$m_fullChainSpec as fullChainSpec, index$m_tinyChainSpec as tinyChainSpec };
+  export { index$m_Bootnode as Bootnode, index$m_ChainSpec as ChainSpec, index$m_EC_SEGMENT_SIZE as EC_SEGMENT_SIZE, index$m_EST_CORES as EST_CORES, index$m_EST_EPOCH_LENGTH as EST_EPOCH_LENGTH, index$m_EST_VALIDATORS as EST_VALIDATORS, index$m_EST_VALIDATORS_SUPER_MAJORITY as EST_VALIDATORS_SUPER_MAJORITY, index$m_PvmBackend as PvmBackend, index$m_PvmBackendNames as PvmBackendNames, index$m_fullChainSpec as fullChainSpec, index$m_tinyChainSpec as tinyChainSpec };
   export type { index$m_PeerAddress as PeerAddress, index$m_PeerId as PeerId };
 }
 
@@ -8164,6 +8169,7 @@ declare const DEFAULT_CONFIG = "default";
 declare const NODE_DEFAULTS = {
   name: isBrowser() ? "browser" : os.hostname(),
   config: DEFAULT_CONFIG,
+  pvm: PvmBackend.BuiltIn,
 };
 
 /** Chain spec chooser. */
@@ -8192,7 +8198,7 @@ declare class NodeConfiguration {
       version: "number",
       flavor: knownChainSpecFromJson,
       chain_spec: JipChainSpec.fromJson,
-      database_base_path: "string",
+      database_base_path: json.optional("string"),
       authorship: AuthorshipOptions.fromJson,
     },
     NodeConfiguration.new,
@@ -8202,7 +8208,7 @@ declare class NodeConfiguration {
     if (version !== 1) {
       throw new Error("Only version=1 config is supported.");
     }
-    return new NodeConfiguration($schema, version, flavor, chain_spec, database_base_path, authorship);
+    return new NodeConfiguration($schema, version, flavor, chain_spec, database_base_path ?? undefined, authorship);
   }
 
   private constructor(
@@ -8210,7 +8216,8 @@ declare class NodeConfiguration {
     public readonly version: number,
     public readonly flavor: KnownChainSpec,
     public readonly chainSpec: JipChainSpec,
-    public readonly databaseBasePath: string,
+    /** If database path is not provided, we load an in-memory db. */
+    public readonly databaseBasePath: string | undefined,
     public readonly authorship: AuthorshipOptions,
   ) {}
 }
@@ -8285,6 +8292,8 @@ interface BlocksDb {
    * NOTE: this is not extrinsic hash!
    */
   getExtrinsic(hash: HeaderHash): ExtrinsicView | null;
+  /** Close the database and free resources. */
+  close(): Promise<void>;
 }
 
 /** In-memory (non-persistent) blocks database. */
@@ -8343,6 +8352,8 @@ declare class InMemoryBlocks implements BlocksDb {
   getExtrinsic(hash: HeaderHash): ExtrinsicView | null {
     return this.extrinsicsByHeaderHash.get(hash) ?? null;
   }
+
+  async close() {}
 }
 
 type StateKey$1 = Opaque<OpaqueHash, "trieStateKey">;
@@ -12251,6 +12262,18 @@ declare class StateEntries {
     return Object.fromEntries(this.entries);
   }
 
+  /** Dump state entries to JSON string (format compatible with stf vectors). */
+  toString() {
+    return JSON.stringify(
+      Array.from(this.entries.entries()).map(([key, value]) => ({
+        key,
+        value,
+      })),
+      null,
+      2,
+    );
+  }
+
   [Symbol.iterator]() {
     return this.entries[Symbol.iterator]();
   }
@@ -12665,7 +12688,7 @@ interface ValuesDb {
    * Missing value is considered an irrecoverable error, so the implementations
    * are free to throw if that happens.
    */
-  get(key: Uint8Array): Uint8Array;
+  get(key: ValueHash): Uint8Array;
 }
 
 /**
@@ -12698,15 +12721,20 @@ declare class LeafDb implements SerializedStateBackend {
     return Result.ok(new LeafDb(leaves, db));
   }
 
+  /** Create leaf db from sorted set of leaves. */
+  static fromLeaves(leaves: SortedSet<LeafNode>, db: ValuesDb): LeafDb {
+    return new LeafDb(leaves, db);
+  }
+
   /** A mapping between an embedded value or db lookup key. */
   private readonly lookup: TruncatedHashDictionary<StateKey, Lookup>;
 
   private constructor(
-    public readonly leaves: SortedSet<LeafNode>,
+    public readonly leafs: SortedSet<LeafNode>,
     public readonly db: ValuesDb,
   ) {
     this.lookup = TruncatedHashDictionary.fromEntries(
-      leaves.array.map((leaf) => {
+      leafs.array.map((leaf) => {
         const key: StateKey = leaf.getKey().asOpaque();
         const value: Lookup = leaf.hasEmbeddedValue()
           ? {
@@ -12715,7 +12743,7 @@ declare class LeafDb implements SerializedStateBackend {
             }
           : {
               kind: LookupKind.DbKey,
-              key: leaf.getValueHash().raw,
+              key: leaf.getValueHash(),
             };
         return [key, value];
       }),
@@ -12741,7 +12769,7 @@ declare class LeafDb implements SerializedStateBackend {
 
   getStateRoot(blake2b: Blake2b): StateRootHash {
     const blake2bTrieHasher = getBlake2bTrieHasher(blake2b);
-    return InMemoryTrie.computeStateRoot(blake2bTrieHasher, this.leaves).asOpaque();
+    return InMemoryTrie.computeStateRoot(blake2bTrieHasher, this.leafs).asOpaque();
   }
 
   intoStateEntries(): StateEntries {
@@ -12775,9 +12803,42 @@ type Lookup =
     }
   | {
       kind: LookupKind.DbKey;
-      key: Uint8Array;
+      key: ValueHash;
     };
 
+declare function updateLeafs(
+  leafs: SortedSet<LeafNode>,
+  blake2b: Blake2b,
+  data: Iterable<[StateEntryUpdateAction, StateKey | TruncatedHash, BytesBlob]>,
+): {
+  values: [ValueHash, BytesBlob][];
+  leafs: SortedSet<LeafNode>;
+} {
+  const blake2bTrieHasher = getBlake2bTrieHasher(blake2b);
+  // We will collect all values that don't fit directly into leaf nodes.
+  const values: [ValueHash, BytesBlob][] = [];
+  for (const [action, key, value] of data) {
+    if (action === StateEntryUpdateAction.Insert) {
+      const leafNode = InMemoryTrie.constructLeaf(blake2bTrieHasher, key.asOpaque(), value);
+      leafs.replace(leafNode);
+      if (!leafNode.hasEmbeddedValue()) {
+        values.push([leafNode.getValueHash(), value]);
+      }
+    } else if (action === StateEntryUpdateAction.Remove) {
+      const leafNode = InMemoryTrie.constructLeaf(blake2bTrieHasher, key.asOpaque(), BytesBlob.empty());
+      leafs.removeOne(leafNode);
+      // TODO [ToDr] Handle ref-counting values or updating some header-hash-based references.
+    } else {
+      assertNever(action);
+    }
+  }
+
+  return {
+    values,
+    leafs,
+  };
+}
+
 /** A potential error that occured during state update. */
 declare enum StateUpdateError {
   /** A conflicting state update has been provided. */
@@ -12785,6 +12846,13 @@ declare enum StateUpdateError {
   /** There was an error committing the changes. */
   Commit = 1,
 }
+
+/** Interface to initialize states db. Typically used in conjunction with `StatesDb`. */
+interface InitStatesDb<T = State> {
+  /** Insert a pre-defined initial state directly into the database. */
+  insertInitialState(headerHash: HeaderHash, initialState: T): Promise<Result$2<OK, StateUpdateError>>;
+}
+
 /**
  * Interface for accessing states stored in the database.
  *
@@ -12810,12 +12878,18 @@ interface StatesDb<T extends State = State> {
 
   /** Retrieve posterior state of given header. */
   getState(header: HeaderHash): T | null;
+
+  /** Close the database and free resources. */
+  close(): Promise<void>;
 }
 
 declare class InMemoryStates implements StatesDb<InMemoryState> {
-  private readonly db: HashDictionary<HeaderHash, BytesBlob> = HashDictionary.new();
+  private readonly db: HashDictionary<HeaderHash, InMemoryState> = HashDictionary.new();
+  private readonly blake2b: Promise<Blake2b>;
 
-  constructor(private readonly spec: ChainSpec) {}
+  constructor(private readonly spec: ChainSpec) {
+    this.blake2b = Blake2b.createHasher();
+  }
 
   async updateAndSetState(
     headerHash: HeaderHash,
@@ -12824,7 +12898,7 @@ declare class InMemoryStates implements StatesDb<InMemoryState> {
   ): Promise<Result$2<OK, StateUpdateError>> {
     const res = state.applyUpdate(update);
     if (res.isOk) {
-      return await this.insertState(headerHash, state);
+      return await this.insertInitialState(headerHash, state);
     }
 
     switch (res.error) {
@@ -12838,32 +12912,126 @@ declare class InMemoryStates implements StatesDb<InMemoryState> {
   }
 
   async getStateRoot(state: InMemoryState): Promise<StateRootHash> {
-    const blake2b = await Blake2b.createHasher();
+    const blake2b = await this.blake2b;
     return StateEntries.serializeInMemory(this.spec, blake2b, state).getRootHash(blake2b);
   }
 
   /** Insert a full state into the database. */
-  async insertState(headerHash: HeaderHash, state: InMemoryState): Promise<Result$2<OK, StateUpdateError>> {
-    const encoded = Encoder.encodeObject(inMemoryStateCodec(this.spec), state, this.spec);
-    this.db.set(headerHash, encoded);
+  async insertInitialState(headerHash: HeaderHash, state: InMemoryState): Promise<Result$2<OK, StateUpdateError>> {
+    const copy = InMemoryState.copyFrom(this.spec, state, state.intoServicesData());
+    this.db.set(headerHash, copy);
     return Result.ok(OK);
   }
 
   getState(headerHash: HeaderHash): InMemoryState | null {
-    const encodedState = this.db.get(headerHash);
-    if (encodedState === undefined) {
+    const state = this.db.get(headerHash);
+    if (state === undefined) {
       return null;
     }
 
-    return Decoder.decodeObject(inMemoryStateCodec(this.spec), encodedState, this.spec);
+    return InMemoryState.copyFrom(this.spec, state, state.intoServicesData());
+  }
+
+  async close() {}
+}
+
+/** Root database. */
+interface RootDb<TBlocks = BlocksDb, TStates = StatesDb> {
+  /** Blocks DB. */
+  getBlocksDb(): TBlocks;
+
+  /** States DB. */
+  getStatesDb(): TStates;
+
+  /** Close access to the DB. */
+  close(): Promise<void>;
+}
+
+/** Abstract serialized-states db. */
+type SerializedStatesDb = StatesDb<SerializedState<LeafDb>> & InitStatesDb<StateEntries>;
+
+/** In-memory serialized-states db. */
+declare class InMemorySerializedStates implements StatesDb<SerializedState<LeafDb>>, InitStatesDb<StateEntries> {
+  private readonly db: HashDictionary<HeaderHash, SortedSet<LeafNode>> = HashDictionary.new();
+  private readonly valuesDb: HashDictionary<ValueHash, BytesBlob> = HashDictionary.new();
+
+  constructor(
+    private readonly spec: ChainSpec,
+    private readonly blake2b: Blake2b,
+  ) {}
+
+  async insertInitialState(headerHash: HeaderHash, entries: StateEntries): Promise<Result$2<OK, StateUpdateError>> {
+    // convert state entries into leafdb
+    const { values, leafs } = updateLeafs(
+      SortedSet.fromArray(leafComparator, []),
+      this.blake2b,
+      Array.from(entries, (x) => [StateEntryUpdateAction.Insert, x[0], x[1]]),
+    );
+
+    // insert values to the db.
+    for (const val of values) {
+      this.valuesDb.set(val[0], val[1]);
+    }
+
+    this.db.set(headerHash, leafs);
+    return Result.ok(OK);
+  }
+
+  async getStateRoot(state: SerializedState<LeafDb>): Promise<StateRootHash> {
+    return state.backend.getStateRoot(this.blake2b);
+  }
+
+  async updateAndSetState(
+    header: HeaderHash,
+    state: SerializedState<LeafDb>,
+    update: Partial<State & ServicesUpdate>,
+  ): Promise<Result$2<OK, StateUpdateError>> {
+    const blake2b = this.blake2b;
+    const updatedValues = serializeStateUpdate(this.spec, blake2b, update);
+    const { values, leafs } = updateLeafs(state.backend.leafs, blake2b, updatedValues);
+
+    // insert values to the db
+    // valuesdb can be shared between all states because it's just
+    // <valuehash> -> <value> mapping and existence is managed by trie leafs.
+    for (const val of values) {
+      this.valuesDb.set(val[0], val[1]);
+    }
+
+    // make sure to clone the leafs before writing, since the collection is re-used.
+    this.db.set(header, SortedSet.fromSortedArray(leafComparator, leafs.slice()));
+
+    return Result.ok(OK);
+  }
+
+  getState(header: HeaderHash): SerializedState<LeafDb> | null {
+    const leafs = this.db.get(header);
+    if (leafs === undefined) {
+      return null;
+    }
+    // now create a leafdb with shared values db.
+    const leafDb = LeafDb.fromLeaves(leafs, {
+      get: (key: ValueHash) => {
+        const val = this.valuesDb.get(key);
+        if (val === undefined) {
+          throw new Error(`Missing value at key: ${key}`);
+        }
+        return val.raw;
+      },
+    });
+    return SerializedState.new(this.spec, this.blake2b, leafDb);
   }
+
+  async close() {}
 }
 
 type index$c_BlocksDb = BlocksDb;
 type index$c_InMemoryBlocks = InMemoryBlocks;
 declare const index$c_InMemoryBlocks: typeof InMemoryBlocks;
+type index$c_InMemorySerializedStates = InMemorySerializedStates;
+declare const index$c_InMemorySerializedStates: typeof InMemorySerializedStates;
 type index$c_InMemoryStates = InMemoryStates;
 declare const index$c_InMemoryStates: typeof InMemoryStates;
+type index$c_InitStatesDb<T = State> = InitStatesDb<T>;
 type index$c_LeafDb = LeafDb;
 declare const index$c_LeafDb: typeof LeafDb;
 type index$c_LeafDbError = LeafDbError;
@@ -12871,13 +13039,16 @@ declare const index$c_LeafDbError: typeof LeafDbError;
 type index$c_Lookup = Lookup;
 type index$c_LookupKind = LookupKind;
 declare const index$c_LookupKind: typeof LookupKind;
+type index$c_RootDb<TBlocks = BlocksDb, TStates = StatesDb> = RootDb<TBlocks, TStates>;
+type index$c_SerializedStatesDb = SerializedStatesDb;
 type index$c_StateUpdateError = StateUpdateError;
 declare const index$c_StateUpdateError: typeof StateUpdateError;
 type index$c_StatesDb<T extends State = State> = StatesDb<T>;
 type index$c_ValuesDb = ValuesDb;
+declare const index$c_updateLeafs: typeof updateLeafs;
 declare namespace index$c {
-  export { index$c_InMemoryBlocks as InMemoryBlocks, index$c_InMemoryStates as InMemoryStates, index$c_LeafDb as LeafDb, index$c_LeafDbError as LeafDbError, index$c_LookupKind as LookupKind, index$c_StateUpdateError as StateUpdateError };
-  export type { index$c_BlocksDb as BlocksDb, index$c_Lookup as Lookup, index$c_StatesDb as StatesDb, index$c_ValuesDb as ValuesDb };
+  export { index$c_InMemoryBlocks as InMemoryBlocks, index$c_InMemorySerializedStates as InMemorySerializedStates, index$c_InMemoryStates as InMemoryStates, index$c_LeafDb as LeafDb, index$c_LeafDbError as LeafDbError, index$c_LookupKind as LookupKind, index$c_StateUpdateError as StateUpdateError, index$c_updateLeafs as updateLeafs };
+  export type { index$c_BlocksDb as BlocksDb, index$c_InitStatesDb as InitStatesDb, index$c_Lookup as Lookup, index$c_RootDb as RootDb, index$c_SerializedStatesDb as SerializedStatesDb, index$c_StatesDb as StatesDb, index$c_ValuesDb as ValuesDb };
 }
 
 /**
@@ -14178,48 +14349,133 @@ declare class PendingTransfer {
   }
 }
 
-/** Gas measuring type. Can be either U64 or U32 for performance reasons. */
-type Gas = BigGas | SmallGas;
 /** A U64 version of `Gas`. */
 type BigGas = Opaque<U64, "BigGas[U64]">;
 /** A U32 version of `Gas`. */
 type SmallGas = Opaque<U32, "SmallGas[U32]">;
-
-/** Attempt to convert given number into U32 gas representation. */
-declare const tryAsSmallGas = (v: number): SmallGas => asOpaqueType(tryAsU32(v));
-
-/** Attempt to convert given number into U64 gas representation. */
-declare const tryAsBigGas = (v: number | bigint): BigGas => asOpaqueType(tryAsU64(v));
-
-/** Attempt to convert given number into gas. */
-declare const tryAsGas = (v: number | bigint): Gas =>
-  typeof v === "number" && v < 2 ** 32 ? tryAsSmallGas(v) : tryAsBigGas(v);
-
-/** Create a new gas counter instance depending on the gas value. */
-declare function gasCounter(gas: Gas): GasCounter {
-  return new GasCounterU64(tryAsU64(gas));
-}
+/** Gas measuring type. Can be either U64 or U32 for performance reasons. */
+type Gas = BigGas | SmallGas;
 
 /** An abstraction over gas counter.
  *
  * It can be optimized to use numbers instead of bigint in case of small gas.
  */
-interface GasCounter {
+interface IGasCounter {
+  /**
+   * Set during initialization of GasCounter.
+   *
+   * NOTE: Needed to calculate `used()` gas.
+   */
+  initialGas: Gas;
+
   /** Return remaining gas. */
   get(): Gas;
 
-  /** Overwrite remaining gas. Prefer sub method instead. */
+  /**
+   * Overwrite remaining gas.
+   *
+   * NOTE: Could cause `used()` gas calculation to be incorrect.
+   *
+   * @see
+   * Prefer sub method instead.
+   */
   set(g: Gas): void;
 
   /** Returns true if there was an underflow. */
   sub(g: Gas): boolean;
+
+  /**
+   * Calculates used gas since creation of GasCounter.
+   *
+   * The interface does not handle negative or more than `initialGas` values.
+   *
+   * NOTE: We can use at most `initialGas` and as little as `0`.
+   */
+  used(): Gas;
+}
+
+type PageFault$1 = {
+  address: U32;
+};
+
+/** Allows store and read segments of memory. */
+interface IMemory {
+  /** Store bytes into memory at given address. */
+  store(address: U32, bytes: Uint8Array): Result$2<OK, PageFault$1>;
+
+  /** Load bytes from memory from given address into given buffer. */
+  read(address: U32, result: Uint8Array): Result$2<OK, PageFault$1>;
 }
 
 declare const NO_OF_REGISTERS$1 = 13;
 
+/** Allow to set and get all registers encoded into little-endian bytes. */
+interface IRegisters {
+  /**
+   * Get all registers encoded into little-endian bytes.
+   *
+   * NOTE: Total length of bytes must be NO_OF_REGISTERS * REGISTER_BYTE_SIZE.
+   */
+  getAllEncoded(): Uint8Array;
+  /**
+   * Set all registers from little-endian encoded bytes.
+   *
+   * NOTE: Total length of bytes must be NO_OF_REGISTERS * REGISTER_BYTE_SIZE.
+   */
+  setAllEncoded(bytes: Uint8Array): void;
+}
+
+/**
+ * Result codes for the PVM execution.
+ *
+ * https://graypaper.fluffylabs.dev/#/ab2cdbd/2e43002e4300?v=0.7.2
+ */
+declare enum Status {
+  /** Continue */
+  OK = 255,
+  /** Finished */
+  HALT = 0,
+  /** Panic */
+  PANIC = 1,
+  /** Page-fault */
+  FAULT = 2,
+  /** Host-call */
+  HOST = 3,
+  /** Out of gas */
+  OOG = 4,
+}
+
+interface IPvmInterpreter {
+  /** Manipulate gas. */
+  readonly gas: IGasCounter;
+
+  /** Manipulate registers. */
+  readonly registers: IRegisters;
+
+  /** Manipulate memory. */
+  readonly memory: IMemory;
+
+  /** Prepare SPI program to be executed. */
+  resetJam(program: Uint8Array, args: Uint8Array, pc: number, gas: Gas): void;
+
+  /** Execute loaded program. */
+  runProgram(): void;
+
+  /** Get current Status. */
+  getStatus(): Status;
+
+  /** Get current Program Counter. */
+  getPC(): number;
+
+  /** Get exit args. Needed in case of HOST or FAULT. */
+  getExitParam(): U32 | null;
+}
+
+// x << 3 === x * 8
+
 type RegisterIndex = Opaque<number, "register index">;
 
-declare class Registers {
+declare class Registers implements IRegisters {
   private asSigned: BigInt64Array;
   private asUnsigned: BigUint64Array;
 
@@ -14229,6 +14485,15 @@ declare class Registers {
     this.asUnsigned = new BigUint64Array(bytes.buffer, bytes.byteOffset);
   }
 
+  getAllEncoded(): Uint8Array {
+    return this.bytes;
+  }
+
+  setAllEncoded(bytes: Uint8Array): void {
+    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: Uint8Array) {
     check`${bytes.length === NO_OF_REGISTERS << REGISTER_SIZE_SHIFT} Invalid size of registers array.`;
     return new Registers(bytes);
@@ -14239,10 +14504,6 @@ declare class Registers {
     return this.bytes.subarray(offset, offset + len);
   }
 
-  getAllBytesAsLittleEndian() {
-    return this.bytes;
-  }
-
   copyFrom(regs: Registers | BigUint64Array) {
     const array = regs instanceof BigUint64Array ? regs : regs.asUnsigned;
     this.asUnsigned.set(array);
@@ -14291,1493 +14552,1856 @@ declare class Registers {
   }
 }
 
-/**
- * Mask class is an implementation of skip function defined in GP.
- *
- * https://graypaper.fluffylabs.dev/#/5f542d7/237201239801
- */
-declare class Mask {
+declare class HostCallMemory {
+  constructor(private readonly memory: IMemory) {}
+
   /**
-   * 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.
+   * Save some bytes into memory under given address.
    *
-   * 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: Given address is U64 (pure register value),
+   * but we use only lower 32-bits.
    */
-  private lookupTableForward: Uint8Array;
-
-  constructor(mask: BitVec) {
-    this.lookupTableForward = this.buildLookupTableForward(mask);
-  }
-
-  isInstruction(index: number) {
-    return this.lookupTableForward[index] === 0;
-  }
+  storeFrom(regAddress: U64, bytes: Uint8Array): Result$2<OK, PageFault$1> {
+    if (bytes.length === 0) {
+      return Result.ok(OK);
+    }
 
-  getNoOfBytesToNextInstruction(index: number) {
-    check`${index >= 0} index (${index}) cannot be a negative number`;
-    return Math.min(this.lookupTableForward[index] ?? 0, MAX_INSTRUCTION_DISTANCE);
+    // NOTE: We always take lower 32 bits from register value.
+    //
+    // https://graypaper.fluffylabs.dev/#/ab2cdbd/25ed0025ed00?v=0.7.2
+    const address = tryAsU32(Number(regAddress & 0xffff_ffffn));
+    return this.memory.store(address, bytes);
   }
 
-  private buildLookupTableForward(mask: BitVec) {
-    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;
+  /**
+   * Read some bytes from memory under given address.
+   *
+   * NOTE: Given address is U64 (pure register value),
+   * but we use only lower 32-bits.
+   */
+  loadInto(output: Uint8Array, regAddress: U64): Result$2<OK, PageFault$1> {
+    if (output.length === 0) {
+      return Result.ok(OK);
     }
-    return table;
-  }
 
-  static empty() {
-    return new Mask(BitVec.empty(0));
+    // https://graypaper.fluffylabs.dev/#/ab2cdbd/25ed0025ed00?v=0.7.2
+    //
+    // NOTE we are taking the the lower U32 part of the register, hence it's safe.
+    const address = tryAsU32(Number(regAddress & 0xffff_ffffn));
+    return this.memory.read(address, output);
   }
 }
 
-declare enum ArgumentType {
-  NO_ARGUMENTS = 0,
-  ONE_IMMEDIATE = 1,
-  TWO_IMMEDIATES = 2,
-  ONE_OFFSET = 3,
-  ONE_REGISTER_ONE_IMMEDIATE = 4,
-  ONE_REGISTER_TWO_IMMEDIATES = 5,
-  ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET = 6,
-  TWO_REGISTERS = 7,
-  TWO_REGISTERS_ONE_IMMEDIATE = 8,
-  TWO_REGISTERS_ONE_OFFSET = 9,
-  TWO_REGISTERS_TWO_IMMEDIATES = 10,
-  THREE_REGISTERS = 11,
-  ONE_REGISTER_ONE_EXTENDED_WIDTH_IMMEDIATE = 12,
-}
-
-declare class ExtendedWitdthImmediateDecoder {
-  private unsignedImmediate: BigUint64Array;
-  private bytes: Uint8Array;
+declare class HostCallRegisters {
+  private readonly registers: DataView;
 
-  constructor() {
-    const buffer = new ArrayBuffer(IMMEDIATE_SIZE);
-    this.unsignedImmediate = new BigUint64Array(buffer);
-    this.bytes = new Uint8Array(buffer);
+  constructor(private readonly bytes: Uint8Array) {
+    this.registers = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
   }
 
-  setBytes(bytes: Uint8Array) {
-    let i = 0;
-    for (; i < bytes.length; i++) {
-      this.bytes[i] = bytes[i];
-    }
-
-    for (; i < IMMEDIATE_SIZE; i++) {
-      this.bytes[i] = 0;
-    }
+  /** Get U64 register value. */
+  get(registerIndex: number): U64 {
+    return tryAsU64(this.registers.getBigUint64(registerIndex * REGISTER_BYTE_SIZE, true));
   }
 
-  getValue() {
-    return this.unsignedImmediate[0];
+  /** Set U64 register value. */
+  set(registerIndex: number, value: U64) {
+    this.registers.setBigUint64(registerIndex * REGISTER_BYTE_SIZE, value, true);
   }
 
-  getBytesAsLittleEndian() {
-    return this.bytes.subarray(0, IMMEDIATE_SIZE);
+  /** Get all registers encoded into little-endian bytes. */
+  getEncoded(): Uint8Array {
+    return this.bytes;
   }
 }
 
-declare class ImmediateDecoder {
-  private u32: Uint32Array;
-  private i32: Int32Array;
-  private u64: BigUint64Array;
-  private i64: BigInt64Array;
-  private view: DataView;
-  private bytes: Uint8Array;
+/** Strictly-typed host call index. */
+type HostCallIndex = Opaque<U32, "HostCallIndex[U32]">;
+/** Attempt to convert a number into `HostCallIndex`. */
+declare const tryAsHostCallIndex = (v: number): HostCallIndex => asOpaqueType(tryAsU32(v));
 
-  constructor() {
-    const buffer = new ArrayBuffer(BUFFER_SIZE);
-    this.u32 = new Uint32Array(buffer);
-    this.i32 = new Int32Array(buffer);
-    this.u64 = new BigUint64Array(buffer);
-    this.i64 = new BigInt64Array(buffer);
-    this.view = new DataView(buffer);
-    this.bytes = new Uint8Array(buffer);
-  }
-
-  setBytes(bytes: Uint8Array) {
-    const n = bytes.length;
-    const msb = n > 0 ? bytes[n - 1] & 0x80 : 0;
-    const noOfBytes = Math.min(n, BUFFER_SIZE);
-    const prefix = msb !== 0 ? 0xff : 0x00;
+/**
+ * Host-call exit reason.
+ *
+ * https://graypaper.fluffylabs.dev/#/ab2cdbd/24a30124a501?v=0.7.2
+ */
+declare enum PvmExecution {
+  Halt = 0,
+  Panic = 1,
+  OOG = 2, // out-of-gas
+}
 
-    for (let i = 0; i < noOfBytes; i++) {
-      this.view.setUint8(i, bytes[i]);
-    }
+/** A utility function to easily trace a bunch of registers. */
+declare function traceRegisters(...regs: number[]) {
+  return regs.map(tryAsRegisterIndex);
+}
 
-    for (let i = n; i < BUFFER_SIZE; i++) {
-      this.view.setUint8(i, prefix);
-    }
-  }
+/** An interface for a host call implementation */
+interface HostCallHandler {
+  /** Index of that host call (i.e. what PVM invokes via `ecalli`) */
+  readonly index: HostCallIndex;
 
   /**
-   * @deprecated Use getU32 instead
+   * The gas cost of invocation of that host call.
+   *
+   * NOTE: `((reg: HostCallRegisters) => Gas)` function is for compatibility reasons: pre GP 0.7.2
    */
-  getUnsigned() {
-    return this.u32[U32_INDEX];
-  }
+  readonly basicGasCost: SmallGas | ((reg: HostCallRegisters) => Gas);
+
+  /** Currently executing service id. */
+  readonly currentServiceId: U32;
+
+  /** Input&Output registers that we should add to tracing log. */
+  readonly tracedRegisters: RegisterIndex[];
 
   /**
-   * @deprecated Use getI32 instead
+   * Actually execute the host call.
+   *
+   * NOTE the call is ALLOWED and expected to modify registers and memory.
    */
-  getSigned() {
-    return this.i32[U32_INDEX];
-  }
+  execute(gas: IGasCounter, regs: HostCallRegisters, memory: HostCallMemory): Promise<undefined | PvmExecution>;
+}
 
-  getU32(): number {
-    return this.u32[U32_INDEX];
-  }
+/** Container for all available host calls. */
+declare class HostCallsManager {
+  private readonly hostCalls = new Map<HostCallIndex, HostCallHandler>();
+  private readonly missing;
 
-  getI32(): number {
-    return this.i32[U32_INDEX];
+  constructor({
+    missing,
+    handlers = [],
+  }: {
+    missing: HostCallHandler;
+    handlers?: HostCallHandler[];
+  }) {
+    this.missing = missing;
+
+    for (const handler of handlers) {
+      check`${this.hostCalls.get(handler.index) === undefined} Overwriting host call handler at index ${handler.index}`;
+      this.hostCalls.set(handler.index, handler);
+    }
   }
 
-  getU64(): bigint {
-    return this.u64[U64_INDEX];
+  /** Get a host call by index. */
+  get(hostCallIndex: HostCallIndex): HostCallHandler {
+    return this.hostCalls.get(hostCallIndex) ?? this.missing;
   }
 
-  getI64(): bigint {
-    return this.i64[U64_INDEX];
+  traceHostCall(
+    context: string,
+    hostCallIndex: HostCallIndex,
+    hostCallHandler: HostCallHandler,
+    registers: HostCallRegisters,
+    gas: Gas,
+  ) {
+    const { currentServiceId } = hostCallHandler;
+    const requested = hostCallIndex !== hostCallHandler.index ? ` (${hostCallIndex})` : "";
+    const name = `${hostCallHandler.constructor.name}:${hostCallHandler.index}`;
+    const registerValues = hostCallHandler.tracedRegisters
+      .map((idx) => [idx.toString().padStart(2, "0"), registers.get(idx)] as const)
+      .filter((v) => v[1] !== 0n)
+      .map(([idx, value]) => {
+        return `r${idx}=${value} (0x${value.toString(16)})`;
+      })
+      .join(", ");
+    logger.insane`[${currentServiceId}] ${context} ${name}${requested}.  Gas: ${gas}. Regs: ${registerValues}.`;
   }
+}
 
-  getBytesAsLittleEndian() {
-    return this.bytes.subarray(0, IMMEDIATE_SIZE);
+/** Create a new gas counter instance depending on the gas value. */
+declare function gasCounter(gas: Gas): IGasCounter {
+  return new GasCounterU64(tryAsU64(gas));
+}
+
+type MemoryIndex = Opaque<number, "memory index">;
+
+declare const tryAsMemoryIndex = (index: number): MemoryIndex => {
+  check`${index >= 0 && index <= MAX_MEMORY_INDEX} Incorrect memory index: ${index}!`;
+  return asOpaqueType(index);
+};
+
+type SbrkIndex = Opaque<number, "sbrk index">;
+
+declare const tryAsSbrkIndex = (index: number): SbrkIndex => {
+  check`${index >= 0 && index <= MAX_MEMORY_INDEX + 1} Incorrect sbrk index: ${index}!`;
+  return asOpaqueType(index);
+};
+
+type PageIndex = Opaque<number, "memory page index">;
+type PageNumber = Opaque<number, "memory page number">;
+
+declare class PageFault implements PageFault$1 {
+  private constructor(
+    public address: U32,
+    public isAccessFault = true,
+  ) {}
+
+  static fromPageNumber(maybePageNumber: number, isAccessFault = false) {
+    const pageNumber = tryAsPageNumber(maybePageNumber);
+    const startPageIndex = getStartPageIndexFromPageNumber(pageNumber);
+    return new PageFault(tryAsU32(startPageIndex), isAccessFault);
   }
 
-  getExtendedBytesAsLittleEndian() {
-    return this.bytes;
+  static fromMemoryIndex(maybeMemoryIndex: number, isAccessFault = false) {
+    const memoryIndex = tryAsMemoryIndex(maybeMemoryIndex % MEMORY_SIZE);
+    const startPageIndex = getStartPageIndex(memoryIndex);
+    return new PageFault(tryAsU32(startPageIndex), isAccessFault);
   }
 }
 
-declare class NibblesDecoder {
-  private byte = new Int8Array(1);
+/**
+ * A representation of open-ended range of consecutive indices in memory,
+ * possibly empty or wrapping around.
+ *
+ * `[start, start + length)`
+ */
+declare class MemoryRange {
+  /**
+   * Exclusive end index of the range.
+   *
+   * NOTE: The index may be wrapped around and smaller than `start`!
+   */
+  public readonly end: MemoryIndex;
+  /**
+   * Inclusive last index of the range (present unless the range is empty).
+   *
+   * NOTE: the index may be wrapped around and smaller than `start`!
+   */
+  public readonly lastIndex: MemoryIndex | null = null;
 
-  setByte(byte: number) {
-    this.byte[0] = byte;
-  }
+  private constructor(
+    public readonly start: MemoryIndex,
+    public readonly length: number,
+  ) {
+    this.end = tryAsMemoryIndex((this.start + this.length) % MEMORY_SIZE);
 
-  getHighNibble() {
-    return (this.byte[0] & 0xf0) >>> 4;
+    if (length > 0) {
+      this.lastIndex = tryAsMemoryIndex((this.end - 1 + MEMORY_SIZE) % MEMORY_SIZE);
+    }
   }
 
-  getLowNibble() {
-    return this.byte[0] & 0x0f;
+  /** Creates a memory range from given starting point and length */
+  static fromStartAndLength(start: MemoryIndex, length: number) {
+    if (!Number.isInteger(length) || length < 0 || length > MEMORY_SIZE) {
+      throw new TypeError(`length must be a non-negative integer and less than ${MEMORY_SIZE}, got ${length}`);
+    }
+
+    return new MemoryRange(start, length);
   }
 
-  getHighNibbleAsRegisterIndex() {
-    return Math.min(this.getHighNibble(), MAX_REGISTER_INDEX);
+  /** Checks if a range is empty (`length === 0`) */
+  isEmpty() {
+    return this.length === 0;
   }
 
-  getLowNibbleAsRegisterIndex() {
-    return Math.min(this.getLowNibble(), MAX_REGISTER_INDEX);
+  /** Returns true if the range is wrapped (`start` >= `end`) and is not empty */
+  isWrapped() {
+    return this.start >= this.end && !this.isEmpty();
   }
 
-  getHighNibbleAsLength() {
-    return Math.min(this.getHighNibble(), MAX_LENGTH);
+  /** Checks if given memory address is within the range */
+  isInRange(address: MemoryIndex) {
+    if (this.isWrapped()) {
+      return address >= this.start || address < this.end;
+    }
+
+    return address >= this.start && address < this.end;
   }
 
-  getLowNibbleAsLength() {
-    return Math.min(this.getLowNibble(), MAX_LENGTH);
+  /** Checks if this range overlaps with another range */
+  overlapsWith(other: MemoryRange) {
+    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)
+    );
   }
 }
 
-type EmptyArgs = {
-  type: ArgumentType.NO_ARGUMENTS;
-  noOfBytesToSkip: number;
-};
-
-type OneImmediateArgs = {
-  type: ArgumentType.ONE_IMMEDIATE;
-  noOfBytesToSkip: number;
-  /** V_X */
-  immediateDecoder: ImmediateDecoder;
-};
+declare abstract class MemoryPage {
+  public start: MemoryIndex;
 
-type ThreeRegistersArgs = {
-  type: ArgumentType.THREE_REGISTERS;
-  noOfBytesToSkip: number;
-  /** W_A */
-  firstRegisterIndex: number;
-  /** W_B */
-  secondRegisterIndex: number;
-  /** W_D */
-  thirdRegisterIndex: number;
-};
+  constructor(pageNumber: PageNumber) {
+    this.start = getStartPageIndexFromPageNumber(pageNumber);
+  }
 
-type TwoRegistersArgs = {
-  type: ArgumentType.TWO_REGISTERS;
-  noOfBytesToSkip: number;
-  /** W_A */
-  firstRegisterIndex: number;
-  /** W_D */
-  secondRegisterIndex: number;
-};
+  /** Returns `true` if the page is writeable. */
+  abstract isWriteable(): boolean;
 
-type TwoRegistersOneImmediateArgs = {
-  type: ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  noOfBytesToSkip: number;
-  /** W_A */
-  firstRegisterIndex: number;
-  /** W_B */
-  secondRegisterIndex: number;
-  /** V_X */
-  immediateDecoder: ImmediateDecoder;
-};
+  /**
+   * Load exactly `length` bytes from memory page, starting at index `address`
+   * into the `res` array.
+   *
+   * Note that the `res` might be bigger than the number of bytes length, but cannot be smaller.
+   *
+   * Returns `null` if copying was successful and [`PageFault`] otherwise.
+   * NOTE That the `result` might be partially modified in case `PageFault` occurs!
+   */
+  abstract loadInto(res: Uint8Array, address: PageIndex, length: number): Result$2<OK, PageFault>;
 
-type OneRegisterOneImmediateArgs = {
-  type: ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-  noOfBytesToSkip: number;
-  /** W_A */
-  registerIndex: number;
-  /** V_X */
-  immediateDecoder: ImmediateDecoder;
-};
+  /**
+   * Copy all bytes from the `data` into the page at index `address`.
+   *
+   * Returns `null` if copying was successful and [`PageFault`] otherwise.
+   */
+  abstract storeFrom(address: PageIndex, data: Uint8Array): Result$2<OK, PageFault>;
+  /**
+   * Get dump of the entire page. Should only be used for the debugger-adapter because it
+   * might be inefficient.
+   */
+  abstract getPageDump(): Uint8Array;
 
-type OneRegisterOneExtendedWidthImmediateArgs = {
-  type: ArgumentType.ONE_REGISTER_ONE_EXTENDED_WIDTH_IMMEDIATE;
-  noOfBytesToSkip: number;
-  /** W_A */
-  registerIndex: number;
-  /** V_X */
-  immediateDecoder: ExtendedWitdthImmediateDecoder;
-};
+  abstract setData(pageIndex: PageIndex, data: Uint8Array): void;
+}
 
-type TwoRegistersTwoImmediatesArgs = {
-  type: ArgumentType.TWO_REGISTERS_TWO_IMMEDIATES;
-  noOfBytesToSkip: number;
-  /** W_A */
-  firstRegisterIndex: number;
-  /** W_B */
-  secondRegisterIndex: number;
-  /** V_X */
-  firstImmediateDecoder: ImmediateDecoder;
-  /** V_Y */
-  secondImmediateDecoder: ImmediateDecoder;
-};
+/**
+ * I had to extend ArrayBuffer type to use resizable ArrayBuffer.
+ * We will be able to remove it when this is merged: https://github.com/microsoft/TypeScript/pull/58573
+ * And then a new version of TypeScript is released.
+ */
+declare global {
+    interface ArrayBufferConstructor {
+        new (length: number, options?: {
+            maxByteLength: number;
+        }): ArrayBuffer;
+    }
+    interface ArrayBuffer {
+        resize(length: number): void;
+    }
+}
 
-type TwoImmediatesArgs = {
-  type: ArgumentType.TWO_IMMEDIATES;
-  noOfBytesToSkip: number;
-  /** V_X */
-  firstImmediateDecoder: ImmediateDecoder;
-  /** V_Y */
-  secondImmediateDecoder: ImmediateDecoder;
+type InitialMemoryState = {
+  memory: Map<PageNumber, MemoryPage>;
+  sbrkIndex: SbrkIndex;
+  endHeapIndex: SbrkIndex;
 };
 
-type TwoRegistersOneOffsetArgs = {
-  type: ArgumentType.TWO_REGISTERS_ONE_OFFSET;
-  noOfBytesToSkip: number;
-  /** W_A */
-  firstRegisterIndex: number;
-  /** W_B */
-  secondRegisterIndex: number;
-  nextPc: number;
-};
+declare enum AccessType {
+  READ = 0,
+  WRITE = 1,
+}
 
-type OneRegisterOneImmediateOneOffsetArgs = {
-  type: ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
-  noOfBytesToSkip: number;
-  /** W_A */
-  registerIndex: number;
-  /** V_X */
-  immediateDecoder: ImmediateDecoder;
-  /** V_Y */
-  nextPc: number;
-};
+declare class Memory implements IMemory {
+  static fromInitialMemory(initialMemoryState: InitialMemoryState) {
+    return new Memory(
+      initialMemoryState?.sbrkIndex,
+      initialMemoryState?.sbrkIndex,
+      initialMemoryState?.endHeapIndex,
+      initialMemoryState?.memory,
+    );
+  }
 
-type OneRegisterTwoImmediatesArgs = {
-  type: ArgumentType.ONE_REGISTER_TWO_IMMEDIATES;
-  noOfBytesToSkip: number;
-  /** W_A */
-  registerIndex: number;
-  /** V_X */
-  firstImmediateDecoder: ImmediateDecoder;
-  /** V_Y */
-  secondImmediateDecoder: ImmediateDecoder;
-};
+  constructor(
+    private sbrkIndex = tryAsSbrkIndex(RESERVED_MEMORY_RANGE.end),
+    private virtualSbrkIndex = tryAsSbrkIndex(RESERVED_MEMORY_RANGE.end),
+    private endHeapIndex = tryAsSbrkIndex(MAX_MEMORY_INDEX),
+    private memory = new Map<PageNumber, MemoryPage>(),
+  ) {}
 
-type OneOffsetArgs = {
-  type: ArgumentType.ONE_OFFSET;
-  noOfBytesToSkip: number;
-  /** V_X */
-  nextPc: number;
-};
+  store(address: U32, bytes: Uint8Array): Result$2<OK, PageFault$1> {
+    return this.storeFrom(tryAsMemoryIndex(address), bytes);
+  }
 
-type Args =
-  | EmptyArgs
-  | OneImmediateArgs
-  | TwoRegistersArgs
-  | ThreeRegistersArgs
-  | TwoRegistersOneImmediateArgs
-  | TwoRegistersTwoImmediatesArgs
-  | OneRegisterOneImmediateOneOffsetArgs
-  | TwoRegistersOneOffsetArgs
-  | OneRegisterOneImmediateArgs
-  | OneOffsetArgs
-  | TwoImmediatesArgs
-  | OneRegisterTwoImmediatesArgs
-  | OneRegisterOneExtendedWidthImmediateArgs;
+  read(address: U32, output: Uint8Array): Result$2<OK, PageFault$1> {
+    return this.loadInto(output, tryAsMemoryIndex(address));
+  }
 
-declare class ArgsDecoder {
-  private nibblesDecoder = new NibblesDecoder();
-  private offsetDecoder = new ImmediateDecoder();
-  private code: Uint8Array = new Uint8Array();
-  private mask: Mask = Mask.empty();
+  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<PageNumber, MemoryPage>(); // TODO [MaSi]: We should keep allocated pages somewhere and reuse it when it is possible
+  }
 
-  reset(code: Uint8Array, mask: Mask) {
-    this.code = code;
-    this.mask = mask;
+  copyFrom(memory: Memory) {
+    this.sbrkIndex = memory.sbrkIndex;
+    this.virtualSbrkIndex = memory.virtualSbrkIndex;
+    this.endHeapIndex = memory.endHeapIndex;
+    this.memory = memory.memory;
   }
 
-  fillArgs<T extends Args>(pc: number, result: T): void {
-    const nextInstructionDistance = 1 + this.mask.getNoOfBytesToNextInstruction(pc + 1);
-    result.noOfBytesToSkip = nextInstructionDistance;
+  storeFrom(address: MemoryIndex, bytes: Uint8Array): Result$2<OK, PageFault> {
+    if (bytes.length === 0) {
+      return Result.ok(OK);
+    }
 
-    switch (result.type) {
-      case ArgumentType.NO_ARGUMENTS:
-        break;
+    logger.insane`MEM[${address}] <- ${BytesBlob.blobFrom(bytes)}`;
+    const pagesResult = this.getPages(address, bytes.length, AccessType.WRITE);
 
-      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;
-      }
+    if (pagesResult.isError) {
+      return Result.error(pagesResult.error, pagesResult.details);
+    }
 
-      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;
-      }
+    const pages = pagesResult.ok;
+    let currentPosition: number = address;
+    let bytesLeft = bytes.length;
 
-      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();
+    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);
 
-        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;
-      }
+      page.storeFrom(pageStartIndex, source);
 
-      case ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET: {
-        const firstByte = this.code[pc + 1];
-        this.nibblesDecoder.setByte(firstByte);
-        result.registerIndex = this.nibblesDecoder.getLowNibbleAsRegisterIndex();
+      currentPosition += bytesToWrite;
+      bytesLeft -= bytesToWrite;
+    }
+    return Result.ok(OK);
+  }
 
-        const immediateLength = this.nibblesDecoder.getHighNibbleAsLength();
-        const immediateStartIndex = pc + 2;
-        const immediateEndIndex = immediateStartIndex + immediateLength;
-        result.immediateDecoder.setBytes(this.code.subarray(immediateStartIndex, immediateEndIndex));
+  private getPages(startAddress: MemoryIndex, length: number, accessType: AccessType): Result$2<MemoryPage[], PageFault> {
+    if (length === 0) {
+      return Result.ok([]);
+    }
 
-        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));
+    const memoryRange = MemoryRange.fromStartAndLength(startAddress, length);
+    const pageRange = PageRange.fromMemoryRange(memoryRange);
 
-        result.nextPc = pc + this.offsetDecoder.getSigned();
-        break;
+    const pages: MemoryPage[] = [];
+
+    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}`,
+        );
       }
 
-      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;
-      }
+      const page = this.memory.get(pageNumber);
 
-      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;
+      if (page === undefined) {
+        return Result.error(PageFault.fromPageNumber(pageNumber), () => `Page fault: page ${pageNumber} not allocated`);
       }
 
-      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;
+      if (accessType === AccessType.WRITE && !page.isWriteable()) {
+        return Result.error(
+          PageFault.fromPageNumber(pageNumber, true),
+          () => `Page fault: attempted to write to read-only page ${pageNumber}`,
+        );
       }
 
-      case ArgumentType.ONE_REGISTER_ONE_IMMEDIATE: {
-        const firstByte = this.code[pc + 1];
-        this.nibblesDecoder.setByte(firstByte);
-        result.registerIndex = this.nibblesDecoder.getLowNibbleAsRegisterIndex();
+      pages.push(page);
+    }
 
-        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;
-      }
+    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: Uint8Array, startAddress: MemoryIndex): Result$2<OK, PageFault> {
+    if (result.length === 0) {
+      return Result.ok(OK);
+    }
 
-      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 pagesResult = this.getPages(startAddress, result.length, AccessType.READ);
 
-        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;
-      }
+    if (pagesResult.isError) {
+      return Result.error(pagesResult.error, pagesResult.details);
+    }
 
-      case ArgumentType.ONE_REGISTER_TWO_IMMEDIATES: {
-        const firstByte = this.code[pc + 1];
-        this.nibblesDecoder.setByte(firstByte);
-        result.registerIndex = this.nibblesDecoder.getLowNibbleAsRegisterIndex();
+    const pages = pagesResult.ok;
 
-        const firstImmediateLength = this.nibblesDecoder.getHighNibbleAsLength();
-        const firstImmediateStartIndex = pc + 2;
-        const firstImmediateEndIndex = firstImmediateStartIndex + firstImmediateLength;
-        const firstImmediateBytes = this.code.subarray(firstImmediateStartIndex, firstImmediateEndIndex);
-        result.firstImmediateDecoder.setBytes(firstImmediateBytes);
+    let currentPosition: number = startAddress;
+    let bytesLeft = result.length;
 
-        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;
-      }
+    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);
 
-      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();
+      page.loadInto(destination, pageStartIndex, bytesToRead);
 
-        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);
+      currentPosition += bytesToRead;
+      bytesLeft -= bytesToRead;
+    }
 
-        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;
-      }
+    logger.insane`MEM[${startAddress}] => ${BytesBlob.blobFrom(result)}`;
+    return Result.ok(OK);
+  }
 
-      case ArgumentType.ONE_REGISTER_ONE_EXTENDED_WIDTH_IMMEDIATE: {
-        const firstByte = this.code[pc + 1];
-        this.nibblesDecoder.setByte(firstByte);
-        result.registerIndex = this.nibblesDecoder.getLowNibbleAsRegisterIndex();
+  sbrk(length: number): SbrkIndex {
+    const currentSbrkIndex = this.sbrkIndex;
+    const currentVirtualSbrkIndex = this.virtualSbrkIndex;
 
-        const immediateStartIndex = pc + 2;
-        const immediateEndIndex = immediateStartIndex + 8;
-        const immediateBytes = this.code.subarray(immediateStartIndex, immediateEndIndex);
-        result.immediateDecoder.setBytes(immediateBytes);
-        break;
-      }
+    // new sbrk index is bigger than 2 ** 32 or endHeapIndex
+    if (MAX_MEMORY_INDEX < currentVirtualSbrkIndex + length || currentVirtualSbrkIndex + length > this.endHeapIndex) {
+      throw new OutOfMemory();
     }
-  }
-}
 
-declare const createResults = () => {
-  const results = new Array(ARGUMENT_TYPE_LENGTH) as Results;
+    const newVirtualSbrkIndex = tryAsSbrkIndex(this.virtualSbrkIndex + length);
 
-  results[ArgumentType.NO_ARGUMENTS] = {
-    type: ArgumentType.NO_ARGUMENTS,
-    noOfBytesToSkip: 1,
-  };
+    // no alllocation needed
+    if (newVirtualSbrkIndex <= currentSbrkIndex) {
+      this.virtualSbrkIndex = newVirtualSbrkIndex;
+      return currentVirtualSbrkIndex;
+    }
 
-  results[ArgumentType.ONE_IMMEDIATE] = {
-    type: ArgumentType.ONE_IMMEDIATE,
-    noOfBytesToSkip: 1,
-    immediateDecoder: new ImmediateDecoder(),
-  };
+    // 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);
 
-  results[ArgumentType.TWO_REGISTERS] = {
-    type: ArgumentType.TWO_REGISTERS,
-    noOfBytesToSkip: 1,
-    firstRegisterIndex: 0,
-    secondRegisterIndex: 0,
-  };
+    for (const pageNumber of rangeToAllocate) {
+      const page = new WriteablePage(pageNumber);
+      this.memory.set(pageNumber, page);
+    }
 
-  results[ArgumentType.THREE_REGISTERS] = {
-    type: ArgumentType.THREE_REGISTERS,
-    noOfBytesToSkip: 1,
-    firstRegisterIndex: 0,
-    secondRegisterIndex: 0,
-    thirdRegisterIndex: 0,
-  };
+    this.virtualSbrkIndex = newVirtualSbrkIndex;
+    this.sbrkIndex = newSbrkIndex;
+    return currentVirtualSbrkIndex;
+  }
 
-  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,
-  };
+  getPageDump(pageNumber: PageNumber) {
+    const page = this.memory.get(pageNumber);
+    return page?.getPageDump() ?? null;
+  }
 
-  results[ArgumentType.TWO_REGISTERS_ONE_OFFSET] = {
-    type: ArgumentType.TWO_REGISTERS_ONE_OFFSET,
-    noOfBytesToSkip: 1,
-    firstRegisterIndex: 0,
-    secondRegisterIndex: 0,
-    nextPc: 0,
-  };
+  getDirtyPages() {
+    return this.memory.keys();
+  }
+}
 
-  results[ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE] = {
-    type: ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE,
-    noOfBytesToSkip: 1,
-    firstRegisterIndex: 0,
-    secondRegisterIndex: 0,
-    immediateDecoder: new ImmediateDecoder(),
-  };
+declare class MemoryBuilder {
+  private readonly initialMemory: Map<PageNumber, MemoryPage> = new Map();
+  private isFinalized = false;
 
-  results[ArgumentType.ONE_REGISTER_ONE_IMMEDIATE] = {
-    type: ArgumentType.ONE_REGISTER_ONE_IMMEDIATE,
-    noOfBytesToSkip: 1,
-    registerIndex: 0,
-    immediateDecoder: new ImmediateDecoder(),
-  };
+  private ensureNotFinalized() {
+    if (this.isFinalized) {
+      throw new FinalizedBuilderModification();
+    }
+  }
 
-  results[ArgumentType.ONE_REGISTER_TWO_IMMEDIATES] = {
-    type: ArgumentType.ONE_REGISTER_TWO_IMMEDIATES,
-    noOfBytesToSkip: 1,
-    registerIndex: 0,
-    firstImmediateDecoder: new ImmediateDecoder(),
-    secondImmediateDecoder: new ImmediateDecoder(),
-  };
+  private ensureNoReservedMemoryUsage(range: MemoryRange) {
+    if (range.overlapsWith(RESERVED_MEMORY_RANGE)) {
+      throw new ReservedMemoryFault();
+    }
+  }
 
-  results[ArgumentType.ONE_OFFSET] = {
-    type: ArgumentType.ONE_OFFSET,
-    noOfBytesToSkip: 1,
-    nextPc: 0,
-  };
+  /**
+   * 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: MemoryIndex, end: MemoryIndex, data: Uint8Array = 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`;
 
-  results[ArgumentType.TWO_IMMEDIATES] = {
-    type: ArgumentType.TWO_IMMEDIATES,
-    noOfBytesToSkip: 1,
-    firstImmediateDecoder: new ImmediateDecoder(),
-    secondImmediateDecoder: new ImmediateDecoder(),
-  };
+    const length = end - start;
+    const range = MemoryRange.fromStartAndLength(start, length);
 
-  results[ArgumentType.TWO_REGISTERS_TWO_IMMEDIATES] = {
-    type: ArgumentType.TWO_REGISTERS_TWO_IMMEDIATES,
-    noOfBytesToSkip: 1,
-    firstImmediateDecoder: new ImmediateDecoder(),
-    secondImmediateDecoder: new ImmediateDecoder(),
-    firstRegisterIndex: 0,
-    secondRegisterIndex: 0,
-  };
+    this.ensureNoReservedMemoryUsage(range);
 
-  results[ArgumentType.ONE_REGISTER_ONE_EXTENDED_WIDTH_IMMEDIATE] = {
-    type: ArgumentType.ONE_REGISTER_ONE_EXTENDED_WIDTH_IMMEDIATE,
-    noOfBytesToSkip: 9,
-    registerIndex: 0,
-    immediateDecoder: new ExtendedWitdthImmediateDecoder(),
-  };
+    const pages = Array.from(PageRange.fromMemoryRange(range));
+    const noOfPages = pages.length;
 
-  return results;
-};
+    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);
+    }
 
-declare enum Instruction {
-  TRAP = 0,
-  FALLTHROUGH = 1,
-  ECALLI = 10,
-  LOAD_IMM_64 = 20,
-  STORE_IMM_U8 = 30,
-  STORE_IMM_U16 = 31,
-  STORE_IMM_U32 = 32,
-  STORE_IMM_U64 = 33,
-  JUMP = 40,
-  JUMP_IND = 50,
-  LOAD_IMM = 51,
-  LOAD_U8 = 52,
-  LOAD_I8 = 53,
-  LOAD_U16 = 54,
-  LOAD_I16 = 55,
-  LOAD_U32 = 56,
-  LOAD_I32 = 57,
-  LOAD_U64 = 58,
-  STORE_U8 = 59,
-  STORE_U16 = 60,
-  STORE_U32 = 61,
-  STORE_U64 = 62,
-  STORE_IMM_IND_U8 = 70,
-  STORE_IMM_IND_U16 = 71,
-  STORE_IMM_IND_U32 = 72,
-  STORE_IMM_IND_U64 = 73,
-  LOAD_IMM_JUMP = 80,
-  BRANCH_EQ_IMM = 81,
-  BRANCH_NE_IMM = 82,
-  BRANCH_LT_U_IMM = 83,
-  BRANCH_LE_U_IMM = 84,
-  BRANCH_GE_U_IMM = 85,
-  BRANCH_GT_U_IMM = 86,
-  BRANCH_LT_S_IMM = 87,
-  BRANCH_LE_S_IMM = 88,
-  BRANCH_GE_S_IMM = 89,
-  BRANCH_GT_S_IMM = 90,
-  MOVE_REG = 100,
-  SBRK = 101,
-  COUNT_SET_BITS_64 = 102,
-  COUNT_SET_BITS_32 = 103,
-  LEADING_ZERO_BITS_64 = 104,
-  LEADING_ZERO_BITS_32 = 105,
-  TRAILING_ZERO_BITS_64 = 106,
-  TRAILING_ZERO_BITS_32 = 107,
-  SIGN_EXTEND_8 = 108,
-  SIGN_EXTEND_16 = 109,
-  ZERO_EXTEND_16 = 110,
-  REVERSE_BYTES = 111,
-  STORE_IND_U8 = 120,
-  STORE_IND_U16 = 121,
-  STORE_IND_U32 = 122,
-  STORE_IND_U64 = 123,
-  LOAD_IND_U8 = 124,
-  LOAD_IND_I8 = 125,
-  LOAD_IND_U16 = 126,
-  LOAD_IND_I16 = 127,
-  LOAD_IND_U32 = 128,
-  LOAD_IND_I32 = 129,
-  LOAD_IND_U64 = 130,
-  ADD_IMM_32 = 131,
-  AND_IMM = 132,
-  XOR_IMM = 133,
-  OR_IMM = 134,
-  MUL_IMM_32 = 135,
-  SET_LT_U_IMM = 136,
-  SET_LT_S_IMM = 137,
-  SHLO_L_IMM_32 = 138,
-  SHLO_R_IMM_32 = 139,
-  SHAR_R_IMM_32 = 140,
-  NEG_ADD_IMM_32 = 141,
-  SET_GT_U_IMM = 142,
-  SET_GT_S_IMM = 143,
-  SHLO_L_IMM_ALT_32 = 144,
-  SHLO_R_IMM_ALT_32 = 145,
-  SHAR_R_IMM_ALT_32 = 146,
-  CMOV_IZ_IMM = 147,
-  CMOV_NZ_IMM = 148,
-  ADD_IMM_64 = 149,
-  MUL_IMM_64 = 150,
-  SHLO_L_IMM_64 = 151,
-  SHLO_R_IMM_64 = 152,
-  SHAR_R_IMM_64 = 153,
-  NEG_ADD_IMM_64 = 154,
-  SHLO_L_IMM_ALT_64 = 155,
-  SHLO_R_IMM_ALT_64 = 156,
-  SHAR_R_IMM_ALT_64 = 157,
-  ROT_R_64_IMM = 158,
-  ROT_R_64_IMM_ALT = 159,
-  ROT_R_32_IMM = 160,
-  ROT_R_32_IMM_ALT = 161,
-  BRANCH_EQ = 170,
-  BRANCH_NE = 171,
-  BRANCH_LT_U = 172,
-  BRANCH_LT_S = 173,
-  BRANCH_GE_U = 174,
-  BRANCH_GE_S = 175,
-  LOAD_IMM_JUMP_IND = 180,
-  ADD_32 = 190,
-  SUB_32 = 191,
-  MUL_32 = 192,
-  DIV_U_32 = 193,
-  DIV_S_32 = 194,
-  REM_U_32 = 195,
-  REM_S_32 = 196,
-  SHLO_L_32 = 197,
-  SHLO_R_32 = 198,
-  SHAR_R_32 = 199,
-  ADD_64 = 200,
-  SUB_64 = 201,
-  MUL_64 = 202,
-  DIV_U_64 = 203,
-  DIV_S_64 = 204,
-  REM_U_64 = 205,
-  REM_S_64 = 206,
-  SHLO_L_64 = 207,
-  SHLO_R_64 = 208,
-  SHAR_R_64 = 209,
-  AND = 210,
-  XOR = 211,
-  OR = 212,
-  MUL_UPPER_S_S = 213,
-  MUL_UPPER_U_U = 214,
-  MUL_UPPER_S_U = 215,
-  SET_LT_U = 216,
-  SET_LT_S = 217,
-  CMOV_IZ = 218,
-  CMOV_NZ = 219,
-  ROT_L_64 = 220,
-  ROT_L_32 = 221,
-  ROT_R_64 = 222,
-  ROT_R_32 = 223,
-  AND_INV = 224,
-  OR_INV = 225,
-  XNOR = 226,
-  MAX = 227,
-  MAX_U = 228,
-  MIN = 229,
-  MIN_U = 230,
-}
+    return this;
+  }
 
-declare const instructionArgumentTypeMap = (() => {
-  const instructionArgumentTypeMap = new Array<ArgumentType>(HIGHEST_INSTRUCTION_NUMBER + 1);
+  /**
+   * 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: MemoryIndex, end: MemoryIndex, data: Uint8Array = 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`;
 
-  instructionArgumentTypeMap[Instruction.TRAP] = ArgumentType.NO_ARGUMENTS;
-  instructionArgumentTypeMap[Instruction.FALLTHROUGH] = ArgumentType.NO_ARGUMENTS;
+    const length = end - start;
+    const range = MemoryRange.fromStartAndLength(start, length);
 
-  instructionArgumentTypeMap[Instruction.ECALLI] = ArgumentType.ONE_IMMEDIATE;
+    this.ensureNoReservedMemoryUsage(range);
 
-  instructionArgumentTypeMap[Instruction.LOAD_IMM_64] = ArgumentType.ONE_REGISTER_ONE_EXTENDED_WIDTH_IMMEDIATE;
+    const pages = Array.from(PageRange.fromMemoryRange(range));
+    const noOfPages = pages.length;
 
-  instructionArgumentTypeMap[Instruction.STORE_IMM_U8] = ArgumentType.TWO_IMMEDIATES;
-  instructionArgumentTypeMap[Instruction.STORE_IMM_U16] = ArgumentType.TWO_IMMEDIATES;
-  instructionArgumentTypeMap[Instruction.STORE_IMM_U32] = ArgumentType.TWO_IMMEDIATES;
-  instructionArgumentTypeMap[Instruction.STORE_IMM_U64] = ArgumentType.TWO_IMMEDIATES;
+    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);
+    }
 
-  instructionArgumentTypeMap[Instruction.JUMP] = ArgumentType.ONE_OFFSET;
+    return this;
+  }
 
-  instructionArgumentTypeMap[Instruction.JUMP_IND] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.LOAD_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.LOAD_U8] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.LOAD_I8] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.LOAD_U16] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.LOAD_I16] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.LOAD_U32] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.LOAD_I32] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.LOAD_U64] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.STORE_U8] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.STORE_U16] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.STORE_U32] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.STORE_U64] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
+  /**
+   * 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: MemoryIndex, data: Uint8Array) {
+    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.`;
 
-  instructionArgumentTypeMap[Instruction.STORE_IMM_IND_U8] = ArgumentType.ONE_REGISTER_TWO_IMMEDIATES;
-  instructionArgumentTypeMap[Instruction.STORE_IMM_IND_U16] = ArgumentType.ONE_REGISTER_TWO_IMMEDIATES;
-  instructionArgumentTypeMap[Instruction.STORE_IMM_IND_U32] = ArgumentType.ONE_REGISTER_TWO_IMMEDIATES;
-  instructionArgumentTypeMap[Instruction.STORE_IMM_IND_U64] = ArgumentType.ONE_REGISTER_TWO_IMMEDIATES;
-
-  instructionArgumentTypeMap[Instruction.LOAD_IMM_JUMP] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
-  instructionArgumentTypeMap[Instruction.BRANCH_EQ_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
-  instructionArgumentTypeMap[Instruction.BRANCH_NE_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
-  instructionArgumentTypeMap[Instruction.BRANCH_LT_U_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
-  instructionArgumentTypeMap[Instruction.BRANCH_LE_U_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
-  instructionArgumentTypeMap[Instruction.BRANCH_GE_U_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
-  instructionArgumentTypeMap[Instruction.BRANCH_GT_U_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
-  instructionArgumentTypeMap[Instruction.BRANCH_LT_S_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
-  instructionArgumentTypeMap[Instruction.BRANCH_LE_S_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
-  instructionArgumentTypeMap[Instruction.BRANCH_GE_S_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
-  instructionArgumentTypeMap[Instruction.BRANCH_GT_S_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
-
-  instructionArgumentTypeMap[Instruction.MOVE_REG] = ArgumentType.TWO_REGISTERS;
-  instructionArgumentTypeMap[Instruction.SBRK] = ArgumentType.TWO_REGISTERS;
-  instructionArgumentTypeMap[Instruction.COUNT_SET_BITS_64] = ArgumentType.TWO_REGISTERS;
-  instructionArgumentTypeMap[Instruction.COUNT_SET_BITS_32] = ArgumentType.TWO_REGISTERS;
-  instructionArgumentTypeMap[Instruction.LEADING_ZERO_BITS_64] = ArgumentType.TWO_REGISTERS;
-  instructionArgumentTypeMap[Instruction.LEADING_ZERO_BITS_32] = ArgumentType.TWO_REGISTERS;
-  instructionArgumentTypeMap[Instruction.TRAILING_ZERO_BITS_64] = ArgumentType.TWO_REGISTERS;
-  instructionArgumentTypeMap[Instruction.TRAILING_ZERO_BITS_32] = ArgumentType.TWO_REGISTERS;
-  instructionArgumentTypeMap[Instruction.SIGN_EXTEND_8] = ArgumentType.TWO_REGISTERS;
-  instructionArgumentTypeMap[Instruction.SIGN_EXTEND_16] = ArgumentType.TWO_REGISTERS;
-  instructionArgumentTypeMap[Instruction.ZERO_EXTEND_16] = ArgumentType.TWO_REGISTERS;
-  instructionArgumentTypeMap[Instruction.REVERSE_BYTES] = ArgumentType.TWO_REGISTERS;
-
-  instructionArgumentTypeMap[Instruction.STORE_IND_U8] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.STORE_IND_U16] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.STORE_IND_U32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.STORE_IND_U64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.LOAD_IND_U8] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.LOAD_IND_I8] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.LOAD_IND_U16] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.LOAD_IND_I16] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.LOAD_IND_U32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.LOAD_IND_I32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.LOAD_IND_U64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.ADD_IMM_32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.ADD_IMM_64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.AND_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.XOR_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.OR_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.MUL_IMM_32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.MUL_IMM_64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.SET_LT_U_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.SET_LT_S_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.SHLO_L_IMM_32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.SHLO_R_IMM_32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.SHAR_R_IMM_32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.NEG_ADD_IMM_32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.SHLO_L_IMM_64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.SHLO_R_IMM_64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.SHAR_R_IMM_64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.NEG_ADD_IMM_64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.SET_GT_U_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.SET_GT_S_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.SHLO_L_IMM_ALT_32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.SHLO_R_IMM_ALT_32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.SHAR_R_IMM_ALT_32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.SHLO_L_IMM_ALT_64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.SHLO_R_IMM_ALT_64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.SHAR_R_IMM_ALT_64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.CMOV_IZ_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.CMOV_NZ_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.ROT_R_64_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.ROT_R_64_IMM_ALT] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.ROT_R_32_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
-  instructionArgumentTypeMap[Instruction.ROT_R_32_IMM_ALT] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+    const length = data.length;
+    const range = MemoryRange.fromStartAndLength(start, length);
 
-  instructionArgumentTypeMap[Instruction.BRANCH_EQ] = ArgumentType.TWO_REGISTERS_ONE_OFFSET;
-  instructionArgumentTypeMap[Instruction.BRANCH_NE] = ArgumentType.TWO_REGISTERS_ONE_OFFSET;
-  instructionArgumentTypeMap[Instruction.BRANCH_LT_U] = ArgumentType.TWO_REGISTERS_ONE_OFFSET;
-  instructionArgumentTypeMap[Instruction.BRANCH_LT_S] = ArgumentType.TWO_REGISTERS_ONE_OFFSET;
-  instructionArgumentTypeMap[Instruction.BRANCH_GE_U] = ArgumentType.TWO_REGISTERS_ONE_OFFSET;
-  instructionArgumentTypeMap[Instruction.BRANCH_GE_S] = ArgumentType.TWO_REGISTERS_ONE_OFFSET;
+    this.ensureNoReservedMemoryUsage(range);
 
-  instructionArgumentTypeMap[Instruction.LOAD_IMM_JUMP_IND] = ArgumentType.TWO_REGISTERS_TWO_IMMEDIATES;
+    const pageNumber = getPageNumber(start);
+    const page = this.initialMemory.get(pageNumber);
 
-  instructionArgumentTypeMap[Instruction.ADD_32] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.ADD_64] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.SUB_32] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.SUB_64] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.AND] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.XOR] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.OR] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.MUL_32] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.MUL_64] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.MUL_UPPER_S_S] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.MUL_UPPER_U_U] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.MUL_UPPER_S_U] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.DIV_U_32] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.DIV_S_32] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.REM_U_32] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.REM_S_32] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.DIV_U_64] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.DIV_S_64] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.REM_U_64] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.REM_S_64] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.SET_LT_U] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.SET_LT_S] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.SHLO_L_32] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.SHLO_R_32] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.SHAR_R_32] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.SHLO_L_64] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.SHLO_R_64] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.SHAR_R_64] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.CMOV_IZ] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.CMOV_NZ] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.ROT_L_64] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.ROT_L_32] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.ROT_R_64] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.ROT_R_32] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.AND_INV] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.OR_INV] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.XNOR] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.MAX] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.MAX_U] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.MIN] = ArgumentType.THREE_REGISTERS;
-  instructionArgumentTypeMap[Instruction.MIN_U] = ArgumentType.THREE_REGISTERS;
+    if (page === undefined) {
+      throw new PageNotExist();
+    }
 
-  return instructionArgumentTypeMap;
-})();
+    const startPageIndex = tryAsPageIndex(start - page.start);
+    page.setData(startPageIndex, data);
 
-declare class BasicBlocks {
-  private basicBlocks: Set<number> = new Set();
+    return this;
+  }
 
-  reset(code: Uint8Array, mask: Mask) {
-    this.basicBlocks.clear();
-    this.basicBlocks.add(0);
-    const codeLength = code.length;
+  finalize(startHeapIndex: MemoryIndex, endHeapIndex: SbrkIndex): Memory {
+    check`
+      ${startHeapIndex <= endHeapIndex}
+      startHeapIndex (${startHeapIndex}) has to be less than or equal to endHeapIndex (${endHeapIndex})
+    `;
+    this.ensureNotFinalized();
 
-    const isBasicBlockTermination = (index: number) =>
-      mask.isInstruction(index) && terminationInstructions[code[index]];
+    const heapRange = MemoryRange.fromStartAndLength(startHeapIndex, endHeapIndex - startHeapIndex);
+    const heapPagesRange = PageRange.fromMemoryRange(heapRange);
+    const initializedPageNumbers = Array.from(this.initialMemory.keys());
 
-    for (let i = 0; i < codeLength; i++) {
-      if (mask.isInstruction(i) && isBasicBlockTermination(i)) {
-        this.basicBlocks.add(i + 1 + mask.getNoOfBytesToNextInstruction(i + 1));
+    for (const pageNumber of initializedPageNumbers) {
+      if (heapPagesRange.isInRange(pageNumber)) {
+        throw new IncorrectSbrkIndex();
       }
     }
-  }
-
-  isBeginningOfBasicBlock(index: number) {
-    return this.basicBlocks.has(index);
-  }
-}
-
-declare enum Result {
-  HALT = 0,
-  PANIC = 1,
-  FAULT_ACCESS = 2,
-  FAULT = 3,
-  HOST = 4,
-}
 
-declare class InstructionResult {
-  public nextPc = 0;
-  public status: Result | null = null;
-  /**
-   * A numeric exit parameter of the PVM.
-   *
-   * In case of a `status === Result.FAULT` this will be the memory address
-   * that triggered the fault.
-   * In case of a `status === Result.HOST` this will be the host call index
-   * that should be invoked.
-   *
-   * In any other circumstance the value should be `null`.
-   */
-  public exitParam: number | null = null;
+    const memory = Memory.fromInitialMemory({
+      memory: this.initialMemory,
+      sbrkIndex: tryAsSbrkIndex(startHeapIndex),
+      endHeapIndex,
+    });
 
-  reset() {
-    this.nextPc = 0;
-    this.status = null;
-    this.exitParam = null;
+    this.isFinalized = true;
+    return memory;
   }
 }
 
-type MemoryIndex = Opaque<number, "memory index">;
-
-declare const tryAsMemoryIndex = (index: number): MemoryIndex => {
-  check`${index >= 0 && index <= MAX_MEMORY_INDEX} Incorrect memory index: ${index}!`;
-  return asOpaqueType(index);
-};
-
-type SbrkIndex = Opaque<number, "sbrk index">;
-
-declare const tryAsSbrkIndex = (index: number): SbrkIndex => {
-  check`${index >= 0 && index <= MAX_MEMORY_INDEX + 1} Incorrect sbrk index: ${index}!`;
-  return asOpaqueType(index);
-};
-
-type PageIndex = Opaque<number, "memory page index">;
-type PageNumber = Opaque<number, "memory page number">;
-
-declare class PageFault {
-  private constructor(
-    public address: MemoryIndex,
-    public isAccessFault = true,
-  ) {}
+declare const NO_OF_REGISTERS = 13;
 
-  static fromPageNumber(maybePageNumber: number, isAccessFault = false) {
-    const pageNumber = tryAsPageNumber(maybePageNumber);
-    const startPageIndex = getStartPageIndexFromPageNumber(pageNumber);
-    return new PageFault(startPageIndex, isAccessFault);
+declare class MemorySegment extends WithDebug {
+  static from({ start, end, data }: Omit<MemorySegment, never>) {
+    return new MemorySegment(start, end, data);
   }
 
-  static fromMemoryIndex(maybeMemoryIndex: number, isAccessFault = false) {
-    const memoryIndex = tryAsMemoryIndex(maybeMemoryIndex % MEMORY_SIZE);
-    const startPageIndex = getStartPageIndex(memoryIndex);
-    return new PageFault(startPageIndex, isAccessFault);
+  constructor(
+    public readonly start: number,
+    public readonly end: number,
+    public readonly data: Uint8Array | null,
+  ) {
+    super();
+  }
+}
+declare class SpiMemory extends WithDebug {
+  constructor(
+    public readonly readable: MemorySegment[],
+    public readonly writeable: MemorySegment[],
+    public readonly sbrkIndex: number,
+    public readonly heapEnd: number,
+  ) {
+    super();
   }
 }
 
-declare class OutOfBounds extends Error {
-  constructor() {
-    super("Out of bounds");
+declare class SpiProgram extends WithDebug {
+  constructor(
+    public readonly code: Uint8Array,
+    public readonly memory: SpiMemory,
+    public readonly registers: BigUint64Array,
+  ) {
+    super();
   }
 }
 
 /**
- * A representation of open-ended range of consecutive indices in memory,
- * possibly empty or wrapping around.
+ * program = E_3(|o|) ++ E_3(|w|) ++ E_2(z) ++ E_3(s) ++ o ++ w ++ E_4(|c|) ++ c
  *
- * `[start, start + length)`
- */
-declare class MemoryRange {
-  /**
-   * Exclusive end index of the range.
-   *
-   * NOTE: The index may be wrapped around and smaller than `start`!
-   */
-  public readonly end: MemoryIndex;
-  /**
-   * Inclusive last index of the range (present unless the range is empty).
-   *
-   * NOTE: the index may be wrapped around and smaller than `start`!
-   */
-  public readonly lastIndex: MemoryIndex | null = null;
+ * E_n - little endian encoding, n - length
+ * o - initial read only data
+ * w - initial heap
+ * z - heap pages filled with zeros
+ * s - stack size
+ * c - program code
+ *
+ * https://graypaper.fluffylabs.dev/#/579bd12/2b92022b9202
+ */
+declare function decodeStandardProgram(program: Uint8Array, args: Uint8Array) {
+  const decoder = Decoder.fromBlob(program);
+  const oLength = decoder.u24();
+  const wLength = decoder.u24();
+  check`${args.length <= DATA_LENGTH} Incorrect arguments length`;
+  check`${oLength <= DATA_LENGTH} Incorrect readonly segment length`;
+  const readOnlyLength = oLength;
+  check`${wLength <= DATA_LENGTH} Incorrect heap segment length`;
+  const heapLength = wLength;
+  const noOfHeapZerosPages = decoder.u16();
+  const stackSize = decoder.u24();
+  const readOnlyMemory = decoder.bytes(readOnlyLength).raw;
+  const initialHeap = decoder.bytes(heapLength).raw;
+  const codeLength = decoder.u32();
+  const code = decoder.bytes(codeLength).raw;
+  decoder.finish();
 
-  private constructor(
-    public readonly start: MemoryIndex,
-    public readonly length: number,
-  ) {
-    this.end = tryAsMemoryIndex((this.start + this.length) % MEMORY_SIZE);
+  const readonlyDataStart = SEGMENT_SIZE;
+  const readonlyDataEnd = SEGMENT_SIZE + alignToPageSize(readOnlyLength);
+  const heapDataStart = 2 * SEGMENT_SIZE + alignToSegmentSize(readOnlyLength);
+  const heapDataEnd = heapDataStart + alignToPageSize(heapLength);
+  const heapZerosEnd = heapDataStart + alignToPageSize(heapLength) + noOfHeapZerosPages * PAGE_SIZE;
+  const stackStart = STACK_SEGMENT - alignToPageSize(stackSize);
+  const stackEnd = STACK_SEGMENT;
+  const argsStart = ARGS_SEGMENT;
+  const argsEnd = argsStart + alignToPageSize(args.length);
+  const argsZerosEnd = argsEnd + alignToPageSize(args.length);
 
-    if (length > 0) {
-      this.lastIndex = tryAsMemoryIndex((this.end - 1 + MEMORY_SIZE) % MEMORY_SIZE);
-    }
+  function nonEmpty(s: MemorySegment | false): s is MemorySegment {
+    return s !== false;
   }
 
-  /** Creates a memory range from given starting point and length */
-  static fromStartAndLength(start: MemoryIndex, length: number) {
-    if (!Number.isInteger(length) || length < 0 || length > MEMORY_SIZE) {
-      throw new TypeError(`length must be a non-negative integer and less than ${MEMORY_SIZE}, got ${length}`);
-    }
-
-    return new MemoryRange(start, length);
-  }
+  const readableMemory = [
+    readOnlyLength > 0 && getMemorySegment(readonlyDataStart, readonlyDataEnd, readOnlyMemory),
+    args.length > 0 && getMemorySegment(argsStart, argsEnd, args),
+    argsEnd < argsZerosEnd && getMemorySegment(argsEnd, argsZerosEnd),
+  ].filter(nonEmpty);
+  const writeableMemory = [
+    heapLength > 0 && getMemorySegment(heapDataStart, heapDataEnd, initialHeap),
+    heapDataEnd < heapZerosEnd && getMemorySegment(heapDataEnd, heapZerosEnd),
+    stackStart < stackEnd && getMemorySegment(stackStart, stackEnd),
+  ].filter(nonEmpty);
 
-  /** Checks if a range is empty (`length === 0`) */
-  isEmpty() {
-    return this.length === 0;
-  }
+  return new SpiProgram(
+    code,
+    new SpiMemory(readableMemory, writeableMemory, heapZerosEnd, stackStart),
+    getRegisters(args.length),
+  );
+}
 
-  /** Returns true if the range is wrapped (`start` >= `end`) and is not empty */
-  isWrapped() {
-    return this.start >= this.end && !this.isEmpty();
-  }
+declare function getMemorySegment(start: number, end: number, data: Uint8Array | null = null) {
+  return new MemorySegment(start, end, data);
+}
 
-  /** Checks if given memory address is within the range */
-  isInRange(address: MemoryIndex) {
-    if (this.isWrapped()) {
-      return address >= this.start || address < this.end;
-    }
+declare function getRegisters(argsLength: number) {
+  const regs = new BigUint64Array(NO_OF_REGISTERS);
 
-    return address >= this.start && address < this.end;
-  }
+  // GP reference: https://graypaper.fluffylabs.dev/#/579bd12/2c7c012cb101
+  regs[0] = BigInt(LAST_PAGE);
+  regs[1] = BigInt(STACK_SEGMENT);
+  regs[7] = BigInt(ARGS_SEGMENT);
+  regs[8] = BigInt(argsLength);
 
-  /** Checks if this range overlaps with another range */
-  overlapsWith(other: MemoryRange) {
-    if (this.lastIndex === null || other.lastIndex === null) {
-      return false;
-    }
+  return regs;
+}
 
-    return (
-      this.isInRange(other.start) ||
-      this.isInRange(other.lastIndex) ||
-      other.isInRange(this.start) ||
-      other.isInRange(this.lastIndex)
-    );
-  }
+type index$8_MemorySegment = MemorySegment;
+declare const index$8_MemorySegment: typeof MemorySegment;
+declare const index$8_NO_OF_REGISTERS: typeof NO_OF_REGISTERS;
+type index$8_SpiMemory = SpiMemory;
+declare const index$8_SpiMemory: typeof SpiMemory;
+type index$8_SpiProgram = SpiProgram;
+declare const index$8_SpiProgram: typeof SpiProgram;
+declare const index$8_decodeStandardProgram: typeof decodeStandardProgram;
+declare const index$8_getMemorySegment: typeof getMemorySegment;
+declare const index$8_getRegisters: typeof getRegisters;
+declare namespace index$8 {
+  export {
+    index$8_MemorySegment as MemorySegment,
+    index$8_NO_OF_REGISTERS as NO_OF_REGISTERS,
+    index$8_SpiMemory as SpiMemory,
+    index$8_SpiProgram as SpiProgram,
+    index$8_decodeStandardProgram as decodeStandardProgram,
+    index$8_getMemorySegment as getMemorySegment,
+    index$8_getRegisters as getRegisters,
+  };
 }
 
-declare abstract class MemoryPage {
-  public start: MemoryIndex;
+declare class Program {
+  static fromSpi(blob: Uint8Array, args: Uint8Array, hasMetadata: boolean) {
+    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();
 
-  constructor(pageNumber: PageNumber) {
-    this.start = getStartPageIndexFromPageNumber(pageNumber);
-  }
+    for (const { start, end, data } of rawMemory.readable) {
+      const startIndex = tryAsMemoryIndex(start);
+      const endIndex = tryAsMemoryIndex(end);
+      memoryBuilder.setReadablePages(startIndex, endIndex, data ?? new Uint8Array());
+    }
 
-  /** Returns `true` if the page is writeable. */
-  abstract isWriteable(): boolean;
+    for (const { start, end, data } of rawMemory.writeable) {
+      const startIndex = tryAsMemoryIndex(start);
+      const endIndex = tryAsMemoryIndex(end);
+      memoryBuilder.setWriteablePages(startIndex, endIndex, data ?? new Uint8Array());
+    }
 
-  /**
-   * Load exactly `length` bytes from memory page, starting at index `address`
-   * into the `res` array.
-   *
-   * Note that the `res` might be bigger than the number of bytes length, but cannot be smaller.
-   *
-   * Returns `null` if copying was successful and [`PageFault`] otherwise.
-   * NOTE That the `result` might be partially modified in case `PageFault` occurs!
-   */
-  abstract loadInto(res: Uint8Array, address: PageIndex, length: number): Result$2<OK, PageFault>;
+    const heapStart = tryAsMemoryIndex(rawMemory.sbrkIndex);
+    const heapEnd = tryAsSbrkIndex(rawMemory.heapEnd);
+    const memory = memoryBuilder.finalize(heapStart, heapEnd);
 
-  /**
-   * Copy all bytes from the `data` into the page at index `address`.
-   *
-   * Returns `null` if copying was successful and [`PageFault`] otherwise.
-   */
-  abstract storeFrom(address: PageIndex, data: Uint8Array): Result$2<OK, PageFault>;
-  /**
-   * Get dump of the entire page. Should only be used for the debugger-adapter because it
-   * might be inefficient.
-   */
-  abstract getPageDump(): Uint8Array;
+    return new Program(code, regs, memory, metadata);
+  }
 
-  abstract setData(pageIndex: PageIndex, data: Uint8Array): void;
+  static fromGeneric(blob: Uint8Array, hasMetadata: boolean) {
+    const { code, metadata } = hasMetadata ? extractCodeAndMetadata(blob) : { code: blob };
+    const regs = new Registers();
+    const memory = new Memory();
+    return new Program(code, regs, memory, metadata);
+  }
+
+  private constructor(
+    public readonly code: Uint8Array,
+    public readonly registers: Registers,
+    public readonly memory: Memory,
+    public metadata: Uint8Array = new Uint8Array(),
+  ) {}
 }
 
 /**
- * I had to extend ArrayBuffer type to use resizable ArrayBuffer.
- * We will be able to remove it when this is merged: https://github.com/microsoft/TypeScript/pull/58573
- * And then a new version of TypeScript is released.
+ * A function that splits preimage into metadata and code.
+ *
+ * https://graypaper.fluffylabs.dev/#/cc517d7/109a01109a01?v=0.6.5
  */
-declare global {
-    interface ArrayBufferConstructor {
-        new (length: number, options?: {
-            maxByteLength: number;
-        }): ArrayBuffer;
-    }
-    interface ArrayBuffer {
-        resize(length: number): void;
-    }
+declare function extractCodeAndMetadata(blobWithMetadata: Uint8Array) {
+  const decoder = Decoder.fromBlob(blobWithMetadata);
+  const metadata = decoder.bytesBlob().raw;
+  const code = decoder.remainingBytes().raw;
+  return { metadata, code };
 }
 
-type InitialMemoryState = {
-  memory: Map<PageNumber, MemoryPage>;
-  sbrkIndex: SbrkIndex;
-  endHeapIndex: SbrkIndex;
-};
-
-declare enum AccessType {
-  READ = 0,
-  WRITE = 1,
+type index$7_Program = Program;
+declare const index$7_Program: typeof Program;
+declare const index$7_extractCodeAndMetadata: typeof extractCodeAndMetadata;
+declare namespace index$7 {
+  export {
+    index$7_Program as Program,
+    index$7_extractCodeAndMetadata as extractCodeAndMetadata,
+  };
 }
 
-declare class Memory {
-  static fromInitialMemory(initialMemoryState: InitialMemoryState) {
-    return new Memory(
-      initialMemoryState?.sbrkIndex,
-      initialMemoryState?.sbrkIndex,
-      initialMemoryState?.endHeapIndex,
-      initialMemoryState?.memory,
-    );
+/**
+ * Mask class is an implementation of skip function defined in GP.
+ *
+ * https://graypaper.fluffylabs.dev/#/5f542d7/237201239801
+ */
+declare class Mask {
+  /**
+   * The lookup table will have `0` at the index which corresponds to an instruction on the same index in the bytecode.
+   * In case the value is non-zero it signifies the offset to the index with next instruction.
+   *
+   * Example:
+   * ```
+   * 0..1..2..3..4..5..6..7..8..9 # Indices
+   * 0..2..1..0..1..0..3..2..1..0 # lookupTable forward values
+   * ```
+   * There are instructions at indices `0, 3, 5, 9`.
+   */
+  private lookupTableForward: Uint8Array;
+
+  constructor(mask: BitVec) {
+    this.lookupTableForward = this.buildLookupTableForward(mask);
   }
 
-  constructor(
-    private sbrkIndex = tryAsSbrkIndex(RESERVED_MEMORY_RANGE.end),
-    private virtualSbrkIndex = tryAsSbrkIndex(RESERVED_MEMORY_RANGE.end),
-    private endHeapIndex = tryAsSbrkIndex(MAX_MEMORY_INDEX),
-    private memory = new Map<PageNumber, MemoryPage>(),
-  ) {}
+  isInstruction(index: number) {
+    return this.lookupTableForward[index] === 0;
+  }
 
-  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<PageNumber, MemoryPage>(); // TODO [MaSi]: We should keep allocated pages somewhere and reuse it when it is possible
-  }
-
-  copyFrom(memory: Memory) {
-    this.sbrkIndex = memory.sbrkIndex;
-    this.virtualSbrkIndex = memory.virtualSbrkIndex;
-    this.endHeapIndex = memory.endHeapIndex;
-    this.memory = memory.memory;
+  getNoOfBytesToNextInstruction(index: number) {
+    check`${index >= 0} index (${index}) cannot be a negative number`;
+    return Math.min(this.lookupTableForward[index] ?? 0, MAX_INSTRUCTION_DISTANCE);
   }
 
-  storeFrom(address: MemoryIndex, bytes: Uint8Array): Result$2<OK, PageFault> {
-    if (bytes.length === 0) {
-      return Result.ok(OK);
-    }
-
-    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);
+  private buildLookupTableForward(mask: BitVec) {
+    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;
+  }
 
-    const pages = pagesResult.ok;
-    let currentPosition: number = address;
-    let bytesLeft = bytes.length;
+  static empty() {
+    return new Mask(BitVec.empty(0));
+  }
+}
 
-    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);
+declare enum ArgumentType {
+  NO_ARGUMENTS = 0,
+  ONE_IMMEDIATE = 1,
+  TWO_IMMEDIATES = 2,
+  ONE_OFFSET = 3,
+  ONE_REGISTER_ONE_IMMEDIATE = 4,
+  ONE_REGISTER_TWO_IMMEDIATES = 5,
+  ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET = 6,
+  TWO_REGISTERS = 7,
+  TWO_REGISTERS_ONE_IMMEDIATE = 8,
+  TWO_REGISTERS_ONE_OFFSET = 9,
+  TWO_REGISTERS_TWO_IMMEDIATES = 10,
+  THREE_REGISTERS = 11,
+  ONE_REGISTER_ONE_EXTENDED_WIDTH_IMMEDIATE = 12,
+}
 
-      page.storeFrom(pageStartIndex, source);
+declare class ExtendedWitdthImmediateDecoder {
+  private unsignedImmediate: BigUint64Array;
+  private bytes: Uint8Array;
 
-      currentPosition += bytesToWrite;
-      bytesLeft -= bytesToWrite;
-    }
-    return Result.ok(OK);
+  constructor() {
+    const buffer = new ArrayBuffer(IMMEDIATE_SIZE);
+    this.unsignedImmediate = new BigUint64Array(buffer);
+    this.bytes = new Uint8Array(buffer);
   }
 
-  private getPages(startAddress: MemoryIndex, length: number, accessType: AccessType): Result$2<MemoryPage[], PageFault> {
-    if (length === 0) {
-      return Result.ok([]);
+  setBytes(bytes: Uint8Array) {
+    let i = 0;
+    for (; i < bytes.length; i++) {
+      this.bytes[i] = bytes[i];
     }
 
-    const memoryRange = MemoryRange.fromStartAndLength(startAddress, length);
-    const pageRange = PageRange.fromMemoryRange(memoryRange);
+    for (; i < IMMEDIATE_SIZE; i++) {
+      this.bytes[i] = 0;
+    }
+  }
 
-    const pages: MemoryPage[] = [];
+  getValue() {
+    return this.unsignedImmediate[0];
+  }
 
-    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}`,
-        );
-      }
+  getBytesAsLittleEndian() {
+    return this.bytes.subarray(0, IMMEDIATE_SIZE);
+  }
+}
 
-      const page = this.memory.get(pageNumber);
+declare class ImmediateDecoder {
+  private u32: Uint32Array;
+  private i32: Int32Array;
+  private u64: BigUint64Array;
+  private i64: BigInt64Array;
+  private view: DataView;
+  private bytes: Uint8Array;
 
-      if (page === undefined) {
-        return Result.error(PageFault.fromPageNumber(pageNumber), () => `Page fault: page ${pageNumber} not allocated`);
-      }
+  constructor() {
+    const buffer = new ArrayBuffer(BUFFER_SIZE);
+    this.u32 = new Uint32Array(buffer);
+    this.i32 = new Int32Array(buffer);
+    this.u64 = new BigUint64Array(buffer);
+    this.i64 = new BigInt64Array(buffer);
+    this.view = new DataView(buffer);
+    this.bytes = new Uint8Array(buffer);
+  }
 
-      if (accessType === AccessType.WRITE && !page.isWriteable()) {
-        return Result.error(
-          PageFault.fromPageNumber(pageNumber, true),
-          () => `Page fault: attempted to write to read-only page ${pageNumber}`,
-        );
-      }
+  setBytes(bytes: Uint8Array) {
+    const n = bytes.length;
+    const msb = n > 0 ? bytes[n - 1] & 0x80 : 0;
+    const noOfBytes = Math.min(n, BUFFER_SIZE);
+    const prefix = msb !== 0 ? 0xff : 0x00;
 
-      pages.push(page);
+    for (let i = 0; i < noOfBytes; i++) {
+      this.view.setUint8(i, bytes[i]);
     }
 
-    return Result.ok(pages);
+    for (let i = n; i < BUFFER_SIZE; i++) {
+      this.view.setUint8(i, prefix);
+    }
   }
+
   /**
-   * 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.
+   * @deprecated Use getU32 instead
    */
-  loadInto(result: Uint8Array, startAddress: MemoryIndex): Result$2<OK, PageFault> {
-    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);
-    }
+  getUnsigned() {
+    return this.u32[U32_INDEX];
+  }
 
-    const pages = pagesResult.ok;
+  /**
+   * @deprecated Use getI32 instead
+   */
+  getSigned() {
+    return this.i32[U32_INDEX];
+  }
 
-    let currentPosition: number = startAddress;
-    let bytesLeft = result.length;
+  getU32(): number {
+    return this.u32[U32_INDEX];
+  }
 
-    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);
+  getI32(): number {
+    return this.i32[U32_INDEX];
+  }
 
-      page.loadInto(destination, pageStartIndex, bytesToRead);
+  getU64(): bigint {
+    return this.u64[U64_INDEX];
+  }
 
-      currentPosition += bytesToRead;
-      bytesLeft -= bytesToRead;
-    }
+  getI64(): bigint {
+    return this.i64[U64_INDEX];
+  }
 
-    logger.insane`MEM[${startAddress}] => ${BytesBlob.blobFrom(result)}`;
-    return Result.ok(OK);
+  getBytesAsLittleEndian() {
+    return this.bytes.subarray(0, IMMEDIATE_SIZE);
   }
 
-  sbrk(length: number): SbrkIndex {
-    const currentSbrkIndex = this.sbrkIndex;
-    const currentVirtualSbrkIndex = this.virtualSbrkIndex;
+  getExtendedBytesAsLittleEndian() {
+    return this.bytes;
+  }
+}
 
-    // new sbrk index is bigger than 2 ** 32 or endHeapIndex
-    if (MAX_MEMORY_INDEX < currentVirtualSbrkIndex + length || currentVirtualSbrkIndex + length > this.endHeapIndex) {
-      throw new OutOfMemory();
-    }
+declare class NibblesDecoder {
+  private byte = new Int8Array(1);
 
-    const newVirtualSbrkIndex = tryAsSbrkIndex(this.virtualSbrkIndex + length);
+  setByte(byte: number) {
+    this.byte[0] = byte;
+  }
 
-    // no alllocation needed
-    if (newVirtualSbrkIndex <= currentSbrkIndex) {
-      this.virtualSbrkIndex = newVirtualSbrkIndex;
-      return currentVirtualSbrkIndex;
-    }
+  getHighNibble() {
+    return (this.byte[0] & 0xf0) >>> 4;
+  }
 
-    // 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);
+  getLowNibble() {
+    return this.byte[0] & 0x0f;
+  }
 
-    for (const pageNumber of rangeToAllocate) {
-      const page = new WriteablePage(pageNumber);
-      this.memory.set(pageNumber, page);
-    }
+  getHighNibbleAsRegisterIndex() {
+    return Math.min(this.getHighNibble(), MAX_REGISTER_INDEX);
+  }
 
-    this.virtualSbrkIndex = newVirtualSbrkIndex;
-    this.sbrkIndex = newSbrkIndex;
-    return currentVirtualSbrkIndex;
+  getLowNibbleAsRegisterIndex() {
+    return Math.min(this.getLowNibble(), MAX_REGISTER_INDEX);
   }
 
-  getPageDump(pageNumber: PageNumber) {
-    const page = this.memory.get(pageNumber);
-    return page?.getPageDump() ?? null;
+  getHighNibbleAsLength() {
+    return Math.min(this.getHighNibble(), MAX_LENGTH);
   }
 
-  getDirtyPages() {
-    return this.memory.keys();
+  getLowNibbleAsLength() {
+    return Math.min(this.getLowNibble(), MAX_LENGTH);
   }
 }
 
-declare class MemoryBuilder {
-  private readonly initialMemory: Map<PageNumber, MemoryPage> = new Map();
-  private isFinalized = false;
-
-  private ensureNotFinalized() {
-    if (this.isFinalized) {
-      throw new FinalizedBuilderModification();
-    }
-  }
+type EmptyArgs = {
+  type: ArgumentType.NO_ARGUMENTS;
+  noOfBytesToSkip: number;
+};
 
-  private ensureNoReservedMemoryUsage(range: MemoryRange) {
-    if (range.overlapsWith(RESERVED_MEMORY_RANGE)) {
-      throw new ReservedMemoryFault();
-    }
-  }
+type OneImmediateArgs = {
+  type: ArgumentType.ONE_IMMEDIATE;
+  noOfBytesToSkip: number;
+  /** V_X */
+  immediateDecoder: ImmediateDecoder;
+};
 
-  /**
-   * 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: MemoryIndex, end: MemoryIndex, data: Uint8Array = 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`;
+type ThreeRegistersArgs = {
+  type: ArgumentType.THREE_REGISTERS;
+  noOfBytesToSkip: number;
+  /** W_A */
+  firstRegisterIndex: number;
+  /** W_B */
+  secondRegisterIndex: number;
+  /** W_D */
+  thirdRegisterIndex: number;
+};
 
-    const length = end - start;
-    const range = MemoryRange.fromStartAndLength(start, length);
+type TwoRegistersArgs = {
+  type: ArgumentType.TWO_REGISTERS;
+  noOfBytesToSkip: number;
+  /** W_A */
+  firstRegisterIndex: number;
+  /** W_D */
+  secondRegisterIndex: number;
+};
 
-    this.ensureNoReservedMemoryUsage(range);
+type TwoRegistersOneImmediateArgs = {
+  type: ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+  noOfBytesToSkip: number;
+  /** W_A */
+  firstRegisterIndex: number;
+  /** W_B */
+  secondRegisterIndex: number;
+  /** V_X */
+  immediateDecoder: ImmediateDecoder;
+};
 
-    const pages = Array.from(PageRange.fromMemoryRange(range));
-    const noOfPages = pages.length;
+type OneRegisterOneImmediateArgs = {
+  type: ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
+  noOfBytesToSkip: number;
+  /** W_A */
+  registerIndex: number;
+  /** V_X */
+  immediateDecoder: ImmediateDecoder;
+};
 
-    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);
-    }
+type OneRegisterOneExtendedWidthImmediateArgs = {
+  type: ArgumentType.ONE_REGISTER_ONE_EXTENDED_WIDTH_IMMEDIATE;
+  noOfBytesToSkip: number;
+  /** W_A */
+  registerIndex: number;
+  /** V_X */
+  immediateDecoder: ExtendedWitdthImmediateDecoder;
+};
 
-    return this;
-  }
+type TwoRegistersTwoImmediatesArgs = {
+  type: ArgumentType.TWO_REGISTERS_TWO_IMMEDIATES;
+  noOfBytesToSkip: number;
+  /** W_A */
+  firstRegisterIndex: number;
+  /** W_B */
+  secondRegisterIndex: number;
+  /** V_X */
+  firstImmediateDecoder: ImmediateDecoder;
+  /** V_Y */
+  secondImmediateDecoder: ImmediateDecoder;
+};
 
-  /**
-   * 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: MemoryIndex, end: MemoryIndex, data: Uint8Array = 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`;
+type TwoImmediatesArgs = {
+  type: ArgumentType.TWO_IMMEDIATES;
+  noOfBytesToSkip: number;
+  /** V_X */
+  firstImmediateDecoder: ImmediateDecoder;
+  /** V_Y */
+  secondImmediateDecoder: ImmediateDecoder;
+};
 
-    const length = end - start;
-    const range = MemoryRange.fromStartAndLength(start, length);
+type TwoRegistersOneOffsetArgs = {
+  type: ArgumentType.TWO_REGISTERS_ONE_OFFSET;
+  noOfBytesToSkip: number;
+  /** W_A */
+  firstRegisterIndex: number;
+  /** W_B */
+  secondRegisterIndex: number;
+  nextPc: number;
+};
 
-    this.ensureNoReservedMemoryUsage(range);
+type OneRegisterOneImmediateOneOffsetArgs = {
+  type: ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
+  noOfBytesToSkip: number;
+  /** W_A */
+  registerIndex: number;
+  /** V_X */
+  immediateDecoder: ImmediateDecoder;
+  /** V_Y */
+  nextPc: number;
+};
 
-    const pages = Array.from(PageRange.fromMemoryRange(range));
-    const noOfPages = pages.length;
+type OneRegisterTwoImmediatesArgs = {
+  type: ArgumentType.ONE_REGISTER_TWO_IMMEDIATES;
+  noOfBytesToSkip: number;
+  /** W_A */
+  registerIndex: number;
+  /** V_X */
+  firstImmediateDecoder: ImmediateDecoder;
+  /** V_Y */
+  secondImmediateDecoder: ImmediateDecoder;
+};
 
-    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);
-    }
+type OneOffsetArgs = {
+  type: ArgumentType.ONE_OFFSET;
+  noOfBytesToSkip: number;
+  /** V_X */
+  nextPc: number;
+};
 
-    return this;
+type Args =
+  | EmptyArgs
+  | OneImmediateArgs
+  | TwoRegistersArgs
+  | ThreeRegistersArgs
+  | TwoRegistersOneImmediateArgs
+  | TwoRegistersTwoImmediatesArgs
+  | OneRegisterOneImmediateOneOffsetArgs
+  | TwoRegistersOneOffsetArgs
+  | OneRegisterOneImmediateArgs
+  | OneOffsetArgs
+  | TwoImmediatesArgs
+  | OneRegisterTwoImmediatesArgs
+  | OneRegisterOneExtendedWidthImmediateArgs;
+
+declare class ArgsDecoder {
+  private nibblesDecoder = new NibblesDecoder();
+  private offsetDecoder = new ImmediateDecoder();
+  private code: Uint8Array = new Uint8Array();
+  private mask: Mask = Mask.empty();
+
+  reset(code: Uint8Array, mask: Mask) {
+    this.code = code;
+    this.mask = mask;
   }
 
-  /**
-   * 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: MemoryIndex, data: Uint8Array) {
-    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.`;
+  fillArgs<T extends Args>(pc: number, result: T): void {
+    const nextInstructionDistance = 1 + this.mask.getNoOfBytesToNextInstruction(pc + 1);
+    result.noOfBytesToSkip = nextInstructionDistance;
 
-    const length = data.length;
-    const range = MemoryRange.fromStartAndLength(start, length);
+    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;
+      }
+    }
+  }
+}
+
+declare const createResults = () => {
+  const results = new Array(ARGUMENT_TYPE_LENGTH) as Results;
+
+  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;
+};
+
+declare enum Instruction {
+  TRAP = 0,
+  FALLTHROUGH = 1,
+  ECALLI = 10,
+  LOAD_IMM_64 = 20,
+  STORE_IMM_U8 = 30,
+  STORE_IMM_U16 = 31,
+  STORE_IMM_U32 = 32,
+  STORE_IMM_U64 = 33,
+  JUMP = 40,
+  JUMP_IND = 50,
+  LOAD_IMM = 51,
+  LOAD_U8 = 52,
+  LOAD_I8 = 53,
+  LOAD_U16 = 54,
+  LOAD_I16 = 55,
+  LOAD_U32 = 56,
+  LOAD_I32 = 57,
+  LOAD_U64 = 58,
+  STORE_U8 = 59,
+  STORE_U16 = 60,
+  STORE_U32 = 61,
+  STORE_U64 = 62,
+  STORE_IMM_IND_U8 = 70,
+  STORE_IMM_IND_U16 = 71,
+  STORE_IMM_IND_U32 = 72,
+  STORE_IMM_IND_U64 = 73,
+  LOAD_IMM_JUMP = 80,
+  BRANCH_EQ_IMM = 81,
+  BRANCH_NE_IMM = 82,
+  BRANCH_LT_U_IMM = 83,
+  BRANCH_LE_U_IMM = 84,
+  BRANCH_GE_U_IMM = 85,
+  BRANCH_GT_U_IMM = 86,
+  BRANCH_LT_S_IMM = 87,
+  BRANCH_LE_S_IMM = 88,
+  BRANCH_GE_S_IMM = 89,
+  BRANCH_GT_S_IMM = 90,
+  MOVE_REG = 100,
+  SBRK = 101,
+  COUNT_SET_BITS_64 = 102,
+  COUNT_SET_BITS_32 = 103,
+  LEADING_ZERO_BITS_64 = 104,
+  LEADING_ZERO_BITS_32 = 105,
+  TRAILING_ZERO_BITS_64 = 106,
+  TRAILING_ZERO_BITS_32 = 107,
+  SIGN_EXTEND_8 = 108,
+  SIGN_EXTEND_16 = 109,
+  ZERO_EXTEND_16 = 110,
+  REVERSE_BYTES = 111,
+  STORE_IND_U8 = 120,
+  STORE_IND_U16 = 121,
+  STORE_IND_U32 = 122,
+  STORE_IND_U64 = 123,
+  LOAD_IND_U8 = 124,
+  LOAD_IND_I8 = 125,
+  LOAD_IND_U16 = 126,
+  LOAD_IND_I16 = 127,
+  LOAD_IND_U32 = 128,
+  LOAD_IND_I32 = 129,
+  LOAD_IND_U64 = 130,
+  ADD_IMM_32 = 131,
+  AND_IMM = 132,
+  XOR_IMM = 133,
+  OR_IMM = 134,
+  MUL_IMM_32 = 135,
+  SET_LT_U_IMM = 136,
+  SET_LT_S_IMM = 137,
+  SHLO_L_IMM_32 = 138,
+  SHLO_R_IMM_32 = 139,
+  SHAR_R_IMM_32 = 140,
+  NEG_ADD_IMM_32 = 141,
+  SET_GT_U_IMM = 142,
+  SET_GT_S_IMM = 143,
+  SHLO_L_IMM_ALT_32 = 144,
+  SHLO_R_IMM_ALT_32 = 145,
+  SHAR_R_IMM_ALT_32 = 146,
+  CMOV_IZ_IMM = 147,
+  CMOV_NZ_IMM = 148,
+  ADD_IMM_64 = 149,
+  MUL_IMM_64 = 150,
+  SHLO_L_IMM_64 = 151,
+  SHLO_R_IMM_64 = 152,
+  SHAR_R_IMM_64 = 153,
+  NEG_ADD_IMM_64 = 154,
+  SHLO_L_IMM_ALT_64 = 155,
+  SHLO_R_IMM_ALT_64 = 156,
+  SHAR_R_IMM_ALT_64 = 157,
+  ROT_R_64_IMM = 158,
+  ROT_R_64_IMM_ALT = 159,
+  ROT_R_32_IMM = 160,
+  ROT_R_32_IMM_ALT = 161,
+  BRANCH_EQ = 170,
+  BRANCH_NE = 171,
+  BRANCH_LT_U = 172,
+  BRANCH_LT_S = 173,
+  BRANCH_GE_U = 174,
+  BRANCH_GE_S = 175,
+  LOAD_IMM_JUMP_IND = 180,
+  ADD_32 = 190,
+  SUB_32 = 191,
+  MUL_32 = 192,
+  DIV_U_32 = 193,
+  DIV_S_32 = 194,
+  REM_U_32 = 195,
+  REM_S_32 = 196,
+  SHLO_L_32 = 197,
+  SHLO_R_32 = 198,
+  SHAR_R_32 = 199,
+  ADD_64 = 200,
+  SUB_64 = 201,
+  MUL_64 = 202,
+  DIV_U_64 = 203,
+  DIV_S_64 = 204,
+  REM_U_64 = 205,
+  REM_S_64 = 206,
+  SHLO_L_64 = 207,
+  SHLO_R_64 = 208,
+  SHAR_R_64 = 209,
+  AND = 210,
+  XOR = 211,
+  OR = 212,
+  MUL_UPPER_S_S = 213,
+  MUL_UPPER_U_U = 214,
+  MUL_UPPER_S_U = 215,
+  SET_LT_U = 216,
+  SET_LT_S = 217,
+  CMOV_IZ = 218,
+  CMOV_NZ = 219,
+  ROT_L_64 = 220,
+  ROT_L_32 = 221,
+  ROT_R_64 = 222,
+  ROT_R_32 = 223,
+  AND_INV = 224,
+  OR_INV = 225,
+  XNOR = 226,
+  MAX = 227,
+  MAX_U = 228,
+  MIN = 229,
+  MIN_U = 230,
+}
+
+declare const instructionArgumentTypeMap = (() => {
+  const instructionArgumentTypeMap = new Array<ArgumentType>(HIGHEST_INSTRUCTION_NUMBER + 1);
+
+  instructionArgumentTypeMap[Instruction.TRAP] = ArgumentType.NO_ARGUMENTS;
+  instructionArgumentTypeMap[Instruction.FALLTHROUGH] = ArgumentType.NO_ARGUMENTS;
+
+  instructionArgumentTypeMap[Instruction.ECALLI] = ArgumentType.ONE_IMMEDIATE;
+
+  instructionArgumentTypeMap[Instruction.LOAD_IMM_64] = ArgumentType.ONE_REGISTER_ONE_EXTENDED_WIDTH_IMMEDIATE;
+
+  instructionArgumentTypeMap[Instruction.STORE_IMM_U8] = ArgumentType.TWO_IMMEDIATES;
+  instructionArgumentTypeMap[Instruction.STORE_IMM_U16] = ArgumentType.TWO_IMMEDIATES;
+  instructionArgumentTypeMap[Instruction.STORE_IMM_U32] = ArgumentType.TWO_IMMEDIATES;
+  instructionArgumentTypeMap[Instruction.STORE_IMM_U64] = ArgumentType.TWO_IMMEDIATES;
+
+  instructionArgumentTypeMap[Instruction.JUMP] = ArgumentType.ONE_OFFSET;
+
+  instructionArgumentTypeMap[Instruction.JUMP_IND] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.LOAD_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.LOAD_U8] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.LOAD_I8] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.LOAD_U16] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.LOAD_I16] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.LOAD_U32] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.LOAD_I32] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.LOAD_U64] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.STORE_U8] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.STORE_U16] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.STORE_U32] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.STORE_U64] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE;
+
+  instructionArgumentTypeMap[Instruction.STORE_IMM_IND_U8] = ArgumentType.ONE_REGISTER_TWO_IMMEDIATES;
+  instructionArgumentTypeMap[Instruction.STORE_IMM_IND_U16] = ArgumentType.ONE_REGISTER_TWO_IMMEDIATES;
+  instructionArgumentTypeMap[Instruction.STORE_IMM_IND_U32] = ArgumentType.ONE_REGISTER_TWO_IMMEDIATES;
+  instructionArgumentTypeMap[Instruction.STORE_IMM_IND_U64] = ArgumentType.ONE_REGISTER_TWO_IMMEDIATES;
+
+  instructionArgumentTypeMap[Instruction.LOAD_IMM_JUMP] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
+  instructionArgumentTypeMap[Instruction.BRANCH_EQ_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
+  instructionArgumentTypeMap[Instruction.BRANCH_NE_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
+  instructionArgumentTypeMap[Instruction.BRANCH_LT_U_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
+  instructionArgumentTypeMap[Instruction.BRANCH_LE_U_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
+  instructionArgumentTypeMap[Instruction.BRANCH_GE_U_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
+  instructionArgumentTypeMap[Instruction.BRANCH_GT_U_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
+  instructionArgumentTypeMap[Instruction.BRANCH_LT_S_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
+  instructionArgumentTypeMap[Instruction.BRANCH_LE_S_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
+  instructionArgumentTypeMap[Instruction.BRANCH_GE_S_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
+  instructionArgumentTypeMap[Instruction.BRANCH_GT_S_IMM] = ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET;
+
+  instructionArgumentTypeMap[Instruction.MOVE_REG] = ArgumentType.TWO_REGISTERS;
+  instructionArgumentTypeMap[Instruction.SBRK] = ArgumentType.TWO_REGISTERS;
+  instructionArgumentTypeMap[Instruction.COUNT_SET_BITS_64] = ArgumentType.TWO_REGISTERS;
+  instructionArgumentTypeMap[Instruction.COUNT_SET_BITS_32] = ArgumentType.TWO_REGISTERS;
+  instructionArgumentTypeMap[Instruction.LEADING_ZERO_BITS_64] = ArgumentType.TWO_REGISTERS;
+  instructionArgumentTypeMap[Instruction.LEADING_ZERO_BITS_32] = ArgumentType.TWO_REGISTERS;
+  instructionArgumentTypeMap[Instruction.TRAILING_ZERO_BITS_64] = ArgumentType.TWO_REGISTERS;
+  instructionArgumentTypeMap[Instruction.TRAILING_ZERO_BITS_32] = ArgumentType.TWO_REGISTERS;
+  instructionArgumentTypeMap[Instruction.SIGN_EXTEND_8] = ArgumentType.TWO_REGISTERS;
+  instructionArgumentTypeMap[Instruction.SIGN_EXTEND_16] = ArgumentType.TWO_REGISTERS;
+  instructionArgumentTypeMap[Instruction.ZERO_EXTEND_16] = ArgumentType.TWO_REGISTERS;
+  instructionArgumentTypeMap[Instruction.REVERSE_BYTES] = ArgumentType.TWO_REGISTERS;
+
+  instructionArgumentTypeMap[Instruction.STORE_IND_U8] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.STORE_IND_U16] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.STORE_IND_U32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.STORE_IND_U64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.LOAD_IND_U8] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.LOAD_IND_I8] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.LOAD_IND_U16] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.LOAD_IND_I16] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.LOAD_IND_U32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.LOAD_IND_I32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.LOAD_IND_U64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.ADD_IMM_32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.ADD_IMM_64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.AND_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.XOR_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.OR_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.MUL_IMM_32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.MUL_IMM_64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.SET_LT_U_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.SET_LT_S_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.SHLO_L_IMM_32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.SHLO_R_IMM_32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.SHAR_R_IMM_32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.NEG_ADD_IMM_32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.SHLO_L_IMM_64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.SHLO_R_IMM_64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.SHAR_R_IMM_64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.NEG_ADD_IMM_64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.SET_GT_U_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.SET_GT_S_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.SHLO_L_IMM_ALT_32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.SHLO_R_IMM_ALT_32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.SHAR_R_IMM_ALT_32] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.SHLO_L_IMM_ALT_64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.SHLO_R_IMM_ALT_64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.SHAR_R_IMM_ALT_64] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.CMOV_IZ_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.CMOV_NZ_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.ROT_R_64_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.ROT_R_64_IMM_ALT] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.ROT_R_32_IMM] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
+  instructionArgumentTypeMap[Instruction.ROT_R_32_IMM_ALT] = ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE;
 
-    this.ensureNoReservedMemoryUsage(range);
+  instructionArgumentTypeMap[Instruction.BRANCH_EQ] = ArgumentType.TWO_REGISTERS_ONE_OFFSET;
+  instructionArgumentTypeMap[Instruction.BRANCH_NE] = ArgumentType.TWO_REGISTERS_ONE_OFFSET;
+  instructionArgumentTypeMap[Instruction.BRANCH_LT_U] = ArgumentType.TWO_REGISTERS_ONE_OFFSET;
+  instructionArgumentTypeMap[Instruction.BRANCH_LT_S] = ArgumentType.TWO_REGISTERS_ONE_OFFSET;
+  instructionArgumentTypeMap[Instruction.BRANCH_GE_U] = ArgumentType.TWO_REGISTERS_ONE_OFFSET;
+  instructionArgumentTypeMap[Instruction.BRANCH_GE_S] = ArgumentType.TWO_REGISTERS_ONE_OFFSET;
 
-    const pageNumber = getPageNumber(start);
-    const page = this.initialMemory.get(pageNumber);
+  instructionArgumentTypeMap[Instruction.LOAD_IMM_JUMP_IND] = ArgumentType.TWO_REGISTERS_TWO_IMMEDIATES;
 
-    if (page === undefined) {
-      throw new PageNotExist();
-    }
+  instructionArgumentTypeMap[Instruction.ADD_32] = ArgumentType.THREE_REGISTERS;
+  instructionArgumentTypeMap[Instruction.ADD_64] = ArgumentType.THREE_REGISTERS;
+  instructionArgumentTypeMap[Instruction.SUB_32] = ArgumentType.THREE_REGISTERS;
+  instructionArgumentTypeMap[Instruction.SUB_64] = ArgumentType.THREE_REGISTERS;
+  instructionArgumentTypeMap[Instruction.AND] = ArgumentType.THREE_REGISTERS;
+  instructionArgumentTypeMap[Instruction.XOR] = ArgumentType.THREE_REGISTERS;
+  instructionArgumentTypeMap[Instruction.OR] = ArgumentType.THREE_REGISTERS;
+  instructionArgumentTypeMap[Instruction.MUL_32] = ArgumentType.THREE_REGISTERS;
+  instructionArgumentTypeMap[Instruction.MUL_64] = ArgumentType.THREE_REGISTERS;
+  instructionArgumentTypeMap[Instruction.MUL_UPPER_S_S] = ArgumentType.THREE_REGISTERS;
+  instructionArgumentTypeMap[Instruction.MUL_UPPER_U_U] = ArgumentType.THREE_REGISTERS;
+  instructionArgumentTypeMap[Instruction.MUL_UPPER_S_U] = ArgumentType.THREE_REGISTERS;
+  instructionArgumentTypeMap[Instruction.DIV_U_32] = ArgumentType.THREE_REGISTERS;
+  instructionArgumentTypeMap[Instruction.DIV_S_32] = ArgumentType.THREE_REGISTERS;
+  instructionArgumentTypeMap[Instruction.REM_U_32] = ArgumentType.THREE_REGISTERS;
+  instructionArgumentTypeMap[Instruction.REM_S_32] = ArgumentType.THREE_REGISTERS;
+  instructionArgumentTypeMap[Instruction.DIV_U_64] = ArgumentType.THREE_REGISTERS;
+  instructionArgumentTypeMap[Instruction.DIV_S_64] = ArgumentType.THREE_REGISTERS;
+  instructionArgumentTypeMap[Instruction.REM_U_64] = ArgumentType.THREE_REGISTERS;
+  instructionArgumentTypeMap[Instruction.REM_S_64] = ArgumentType.THREE_REGISTERS;
+  instructionArgumentTypeMap[Instruction.SET_LT_U] = ArgumentType.THREE_REGISTERS;
+  instructionArgumentTypeMap[Instruction.SET_LT_S] = ArgumentType.THREE_REGISTERS;
+  instructionArgumentTypeMap[Instruction.SHLO_L_32] = ArgumentType.THREE_REGISTERS;
+  instructionArgumentTypeMap[Instruction.SHLO_R_32] = ArgumentType.THREE_REGISTERS;
+  instructionArgumentTypeMap[Instruction.SHAR_R_32] = ArgumentType.THREE_REGISTERS;
+  instructionArgumentTypeMap[Instruction.SHLO_L_64] = ArgumentType.THREE_REGISTERS;
+  instructionArgumentTypeMap[Instruction.SHLO_R_64] = ArgumentType.THREE_REGISTERS;
+  instructionArgumentTypeMap[Instruction.SHAR_R_64] = ArgumentType.THREE_REGISTERS;
+  instructionArgumentTypeMap[Instruction.CMOV_IZ] = ArgumentType.THREE_REGISTERS;
+  instructionArgumentTypeMap[Instruction.CMOV_NZ] = ArgumentType.THREE_REGISTERS;
+  instructionArgumentTypeMap[Instruction.ROT_L_64] = ArgumentType.THREE_REGISTERS;
+  instructionArgumentTypeMap[Instruction.ROT_L_32] = ArgumentType.THREE_REGISTERS;
+  instructionArgumentTypeMap[Instruction.ROT_R_64] = ArgumentType.THREE_REGISTERS;
+  instructionArgumentTypeMap[Instruction.ROT_R_32] = ArgumentType.THREE_REGISTERS;
+  instructionArgumentTypeMap[Instruction.AND_INV] = ArgumentType.THREE_REGISTERS;
+  instructionArgumentTypeMap[Instruction.OR_INV] = ArgumentType.THREE_REGISTERS;
+  instructionArgumentTypeMap[Instruction.XNOR] = ArgumentType.THREE_REGISTERS;
+  instructionArgumentTypeMap[Instruction.MAX] = ArgumentType.THREE_REGISTERS;
+  instructionArgumentTypeMap[Instruction.MAX_U] = ArgumentType.THREE_REGISTERS;
+  instructionArgumentTypeMap[Instruction.MIN] = ArgumentType.THREE_REGISTERS;
+  instructionArgumentTypeMap[Instruction.MIN_U] = ArgumentType.THREE_REGISTERS;
 
-    const startPageIndex = tryAsPageIndex(start - page.start);
-    page.setData(startPageIndex, data);
+  return instructionArgumentTypeMap;
+})();
 
-    return this;
-  }
+declare class BasicBlocks {
+  private basicBlocks: Set<number> = new Set();
 
-  finalize(startHeapIndex: MemoryIndex, endHeapIndex: SbrkIndex): Memory {
-    check`
-      ${startHeapIndex <= endHeapIndex}
-      startHeapIndex (${startHeapIndex}) has to be less than or equal to endHeapIndex (${endHeapIndex})
-    `;
-    this.ensureNotFinalized();
+  reset(code: Uint8Array, mask: Mask) {
+    this.basicBlocks.clear();
+    this.basicBlocks.add(0);
+    const codeLength = code.length;
 
-    const heapRange = MemoryRange.fromStartAndLength(startHeapIndex, endHeapIndex - startHeapIndex);
-    const heapPagesRange = PageRange.fromMemoryRange(heapRange);
-    const initializedPageNumbers = Array.from(this.initialMemory.keys());
+    const isBasicBlockTermination = (index: number) =>
+      mask.isInstruction(index) && terminationInstructions[code[index]];
 
-    for (const pageNumber of initializedPageNumbers) {
-      if (heapPagesRange.isInRange(pageNumber)) {
-        throw new IncorrectSbrkIndex();
+    for (let i = 0; i < codeLength; i++) {
+      if (mask.isInstruction(i) && isBasicBlockTermination(i)) {
+        this.basicBlocks.add(i + 1 + mask.getNoOfBytesToNextInstruction(i + 1));
       }
     }
+  }
 
-    const memory = Memory.fromInitialMemory({
-      memory: this.initialMemory,
-      sbrkIndex: tryAsSbrkIndex(startHeapIndex),
-      endHeapIndex,
-    });
+  isBeginningOfBasicBlock(index: number) {
+    return this.basicBlocks.has(index);
+  }
+}
 
-    this.isFinalized = true;
-    return memory;
+declare enum Result {
+  HALT = 0,
+  PANIC = 1,
+  FAULT_ACCESS = 2,
+  FAULT = 3,
+  HOST = 4,
+}
+
+declare class InstructionResult {
+  public nextPc = 0;
+  public status: Result | null = null;
+  /**
+   * A numeric exit parameter of the PVM.
+   *
+   * In case of a `status === Result.FAULT` this will be the memory address
+   * that triggered the fault.
+   * In case of a `status === Result.HOST` this will be the host call index
+   * that should be invoked.
+   *
+   * In any other circumstance the value should be `null`.
+   */
+  public exitParam: number | null = null;
+
+  reset() {
+    this.nextPc = 0;
+    this.status = null;
+    this.exitParam = null;
   }
 }
 
@@ -16762,7 +17386,7 @@ declare class StoreOps {
       this.instructionResult.status = Result.FAULT_ACCESS;
     } else {
       this.instructionResult.status = Result.FAULT;
-      this.instructionResult.exitParam = getStartPageIndex(storeResult.error.address);
+      this.instructionResult.exitParam = getStartPageIndex(tryAsMemoryIndex(storeResult.error.address));
     }
   }
 }
@@ -17563,34 +18187,20 @@ declare class ProgramDecoder {
   }
 }
 
-/**
- * Inner status codes for the PVM
- *
- * https://graypaper.fluffylabs.dev/#/85129da/2cae022cae02?v=0.6.3
- */
-declare enum Status {
-  OK = 255,
-  HALT = 0,
-  PANIC = 1,
-  FAULT = 2,
-  HOST = 3,
-  OOG = 4,
-}
-
 type InterpreterOptions = {
   useSbrkGas?: boolean;
 };
 
 declare const logger = Logger.new(import.meta.filename, "pvm");
 
-declare class Interpreter {
+declare class Interpreter implements IPvmInterpreter {
   private readonly useSbrkGas: boolean;
-  private registers = new Registers();
+  readonly registers = new Registers();
+  readonly memory = new Memory();
+  gas = gasCounter(tryAsGas(0));
   private code: Uint8Array = new Uint8Array();
   private mask = Mask.empty();
   private pc = 0;
-  private gas = gasCounter(tryAsGas(0));
-  private initialGas = gasCounter(tryAsGas(0));
   private argsDecoder: ArgsDecoder;
   private threeRegsDispatcher: ThreeRegsDispatcher;
   private twoRegsOneImmDispatcher: TwoRegsOneImmDispatcher;
@@ -17600,7 +18210,6 @@ declare class Interpreter {
   private oneOffsetDispatcher: OneOffsetDispatcher;
   private oneRegOneImmDispatcher: OneRegOneImmDispatcher;
   private instructionResult = new InstructionResult();
-  private memory = new Memory();
   private twoImmsDispatcher: TwoImmsDispatcher;
   private oneRegTwoImmsDispatcher: OneRegTwoImmsDispatcher;
   private noArgsDispatcher: NoArgsDispatcher;
@@ -17654,7 +18263,12 @@ declare class Interpreter {
     this.oneRegOneExtImmDispatcher = new OneRegOneExtImmDispatcher(loadOps);
   }
 
-  reset(rawProgram: Uint8Array, pc: number, gas: Gas, maybeRegisters?: Registers, maybeMemory?: Memory) {
+  resetJam(program: Uint8Array, args: Uint8Array, pc: number, gas: Gas) {
+    const p = Program.fromSpi(program, args, true);
+    this.resetGeneric(p.code, pc, gas, p.registers, p.memory);
+  }
+
+  resetGeneric(rawProgram: Uint8Array, pc: number, gas: Gas, maybeRegisters?: Registers, maybeMemory?: Memory) {
     const programDecoder = new ProgramDecoder(rawProgram);
     this.code = programDecoder.getCode();
     this.mask = programDecoder.getMask();
@@ -17662,7 +18276,6 @@ declare class Interpreter {
 
     this.pc = pc;
     this.gas = gasCounter(gas);
-    this.initialGas = gasCounter(gas);
     this.status = Status.OK;
     this.argsDecoder.reset(this.code, this.mask);
     this.basicBlocks.reset(this.code, this.mask);
@@ -17804,10 +18417,6 @@ declare class Interpreter {
     return this.status;
   }
 
-  getRegisters() {
-    return this.registers;
-  }
-
   getPC() {
     return this.pc;
   }
@@ -17816,258 +18425,91 @@ declare class Interpreter {
     this.pc = nextPc;
   }
 
-  getGas(): Gas {
-    return this.gas.get();
-  }
-
-  getGasConsumed(): Gas {
-    const gasConsumed = tryAsBigGas(this.initialGas.get()) - tryAsBigGas(this.gas.get());
-
-    if (gasConsumed < 0) {
-      return this.initialGas.get();
-    }
-
-    return tryAsBigGas(gasConsumed);
-  }
-
-  getGasCounter(): GasCounter {
-    return this.gas;
-  }
-
   getStatus() {
     return this.status;
   }
 
   getExitParam(): null | U32 {
     const p = this.instructionResult.exitParam;
-    return p !== null ? tryAsU32(p) : p;
-  }
-
-  getMemory() {
-    return this.memory;
-  }
-
-  getMemoryPage(pageNumber: number): null | Uint8Array {
-    return this.memory.getPageDump(tryAsPageNumber(pageNumber));
-  }
-
-  calculateBlockGasCost(): Map<string, number> {
-    const codeLength = this.code.length;
-    const blocks: Map<string, number> = new Map();
-    let currentBlock = "0";
-    let gasCost = 0;
-    const getNextIstructionIndex = (index: number) => index + 1 + this.mask.getNoOfBytesToNextInstruction(index + 1);
-
-    for (let index = 0; index < codeLength; index = getNextIstructionIndex(index)) {
-      const instruction = this.code[index];
-      if (this.basicBlocks.isBeginningOfBasicBlock(index)) {
-        blocks.set(currentBlock, gasCost);
-        currentBlock = index.toString();
-        gasCost = 0;
-      }
-
-      gasCost += instructionGasMap[instruction];
-    }
-
-    blocks.set(currentBlock, gasCost);
-
-    return blocks;
-  }
-}
-
-type index$8_BigGas = BigGas;
-type index$8_Gas = Gas;
-type index$8_GasCounter = GasCounter;
-type index$8_Interpreter = Interpreter;
-declare const index$8_Interpreter: typeof Interpreter;
-type index$8_InterpreterOptions = InterpreterOptions;
-type index$8_Memory = Memory;
-declare const index$8_Memory: typeof Memory;
-type index$8_MemoryBuilder = MemoryBuilder;
-declare const index$8_MemoryBuilder: typeof MemoryBuilder;
-type index$8_MemoryIndex = MemoryIndex;
-type index$8_Registers = Registers;
-declare const index$8_Registers: typeof Registers;
-type index$8_SbrkIndex = SbrkIndex;
-type index$8_SmallGas = SmallGas;
-declare const index$8_gasCounter: typeof gasCounter;
-declare const index$8_logger: typeof logger;
-declare const index$8_tryAsBigGas: typeof tryAsBigGas;
-declare const index$8_tryAsGas: typeof tryAsGas;
-declare const index$8_tryAsMemoryIndex: typeof tryAsMemoryIndex;
-declare const index$8_tryAsSbrkIndex: typeof tryAsSbrkIndex;
-declare const index$8_tryAsSmallGas: typeof tryAsSmallGas;
-declare namespace index$8 {
-  export { index$8_Interpreter as Interpreter, index$8_Memory as Memory, index$8_MemoryBuilder as MemoryBuilder, index$8_Registers as Registers, index$8_gasCounter as gasCounter, index$8_logger as logger, index$8_tryAsBigGas as tryAsBigGas, index$8_tryAsGas as tryAsGas, index$8_tryAsMemoryIndex as tryAsMemoryIndex, index$8_tryAsSbrkIndex as tryAsSbrkIndex, index$8_tryAsSmallGas as tryAsSmallGas };
-  export type { index$8_BigGas as BigGas, index$8_Gas as Gas, index$8_GasCounter as GasCounter, index$8_InterpreterOptions as InterpreterOptions, index$8_MemoryIndex as MemoryIndex, index$8_SbrkIndex as SbrkIndex, index$8_SmallGas as SmallGas };
-}
-
-interface IHostCallMemory {
-  storeFrom(address: U64, bytes: Uint8Array): Result$2<OK, PageFault | OutOfBounds>;
-  loadInto(result: Uint8Array, startAddress: U64): Result$2<OK, PageFault | OutOfBounds>;
-}
-
-declare class HostCallMemory implements IHostCallMemory {
-  constructor(private readonly memory: Memory) {}
-
-  storeFrom(address: U64, bytes: Uint8Array): Result$2<OK, PageFault | OutOfBounds> {
-    if (bytes.length === 0) {
-      return Result.ok(OK);
-    }
-
-    if (address + tryAsU64(bytes.length) > MEMORY_SIZE) {
-      return Result.error(
-        new OutOfBounds(),
-        () => `Memory access out of bounds: address ${address} + length ${bytes.length} exceeds memory size`,
-      );
-    }
-
-    return this.memory.storeFrom(tryAsMemoryIndex(Number(address)), bytes);
-  }
-
-  loadInto(result: Uint8Array, startAddress: U64): Result$2<OK, PageFault | OutOfBounds> {
-    if (result.length === 0) {
-      return Result.ok(OK);
-    }
-
-    if (startAddress + tryAsU64(result.length) > MEMORY_SIZE) {
-      return Result.error(
-        new OutOfBounds(),
-        () => `Memory access out of bounds: address ${startAddress} + length ${result.length} exceeds memory size`,
-      );
-    }
-
-    return this.memory.loadInto(result, tryAsMemoryIndex(Number(startAddress)));
-  }
-}
-
-interface IHostCallRegisters {
-  get(registerIndex: number): U64;
-  set(registerIndex: number, value: U64): void;
-}
-
-declare class HostCallRegisters implements IHostCallRegisters {
-  constructor(private readonly registers: Registers) {}
-
-  get(registerIndex: number): U64 {
-    return tryAsU64(this.registers.getU64(registerIndex));
-  }
-
-  set(registerIndex: number, value: U64) {
-    this.registers.setU64(registerIndex, value);
-  }
-}
-
-/** Strictly-typed host call index. */
-type HostCallIndex = Opaque<U32, "HostCallIndex[U32]">;
-/** Attempt to convert a number into `HostCallIndex`. */
-declare const tryAsHostCallIndex = (v: number): HostCallIndex => asOpaqueType(tryAsU32(v));
-
-/**
- * Host-call exit reason.
- *
- * https://graypaper.fluffylabs.dev/#/ab2cdbd/24a30124a501?v=0.7.2
- */
-declare enum PvmExecution {
-  Halt = 0,
-  Panic = 1,
-  OOG = 2, // out-of-gas
-}
-
-/** A utility function to easily trace a bunch of registers. */
-declare function traceRegisters(...regs: number[]) {
-  return regs.map(tryAsRegisterIndex);
-}
-
-/** An interface for a host call implementation */
-interface HostCallHandler {
-  /** Index of that host call (i.e. what PVM invokes via `ecalli`) */
-  readonly index: HostCallIndex;
-
-  /**
-   * The gas cost of invocation of that host call.
-   *
-   * NOTE: `((reg: IHostCallRegisters) => Gas)` function is for compatibility reasons: pre GP 0.7.2
-   */
-  readonly basicGasCost: SmallGas | ((reg: IHostCallRegisters) => Gas);
-
-  /** Currently executing service id. */
-  readonly currentServiceId: U32;
-
-  /** Input&Output registers that we should add to tracing log. */
-  readonly tracedRegisters: RegisterIndex[];
+    return p !== null ? tryAsU32(p) : p;
+  }
 
-  /**
-   * Actually execute the host call.
-   *
-   * NOTE the call is ALLOWED and expected to modify registers and memory.
-   */
-  execute(gas: GasCounter, regs: IHostCallRegisters, memory: IHostCallMemory): Promise<undefined | PvmExecution>;
-}
+  getMemoryPage(pageNumber: number): null | Uint8Array {
+    return this.memory.getPageDump(tryAsPageNumber(pageNumber));
+  }
 
-/** Container for all available host calls. */
-declare class HostCallsManager {
-  private readonly hostCalls = new Map<HostCallIndex, HostCallHandler>();
-  private readonly missing;
+  calculateBlockGasCost(): Map<string, number> {
+    const codeLength = this.code.length;
+    const blocks: Map<string, number> = new Map();
+    let currentBlock = "0";
+    let gasCost = 0;
+    const getNextIstructionIndex = (index: number) => index + 1 + this.mask.getNoOfBytesToNextInstruction(index + 1);
 
-  constructor({
-    missing,
-    handlers = [],
-  }: {
-    missing: HostCallHandler;
-    handlers?: HostCallHandler[];
-  }) {
-    this.missing = missing;
+    for (let index = 0; index < codeLength; index = getNextIstructionIndex(index)) {
+      const instruction = this.code[index];
+      if (this.basicBlocks.isBeginningOfBasicBlock(index)) {
+        blocks.set(currentBlock, gasCost);
+        currentBlock = index.toString();
+        gasCost = 0;
+      }
 
-    for (const handler of handlers) {
-      check`${this.hostCalls.get(handler.index) === undefined} Overwriting host call handler at index ${handler.index}`;
-      this.hostCalls.set(handler.index, handler);
+      gasCost += instructionGasMap[instruction];
     }
-  }
 
-  /** Get a host call by index. */
-  get(hostCallIndex: HostCallIndex): HostCallHandler {
-    return this.hostCalls.get(hostCallIndex) ?? this.missing;
-  }
+    blocks.set(currentBlock, gasCost);
 
-  traceHostCall(
-    context: string,
-    hostCallIndex: HostCallIndex,
-    hostCallHandler: HostCallHandler,
-    registers: IHostCallRegisters,
-    gas: Gas,
-  ) {
-    const { currentServiceId } = hostCallHandler;
-    const requested = hostCallIndex !== hostCallHandler.index ? ` (${hostCallIndex})` : "";
-    const name = `${hostCallHandler.constructor.name}:${hostCallHandler.index}`;
-    const registerValues = hostCallHandler.tracedRegisters
-      .map((idx) => [idx.toString().padStart(2, "0"), registers.get(idx)] as const)
-      .filter((v) => v[1] !== 0n)
-      .map(([idx, value]) => {
-        return `r${idx}=${value} (0x${value.toString(16)})`;
-      })
-      .join(", ");
-    logger.insane`[${currentServiceId}] ${context} ${name}${requested}.  Gas: ${gas}. Regs: ${registerValues}.`;
+    return blocks;
   }
 }
 
-type ResolveFn = (pvm: Interpreter) => void;
+type index$6_Interpreter = Interpreter;
+declare const index$6_Interpreter: typeof Interpreter;
+type index$6_InterpreterOptions = InterpreterOptions;
+type index$6_Memory = Memory;
+declare const index$6_Memory: typeof Memory;
+type index$6_MemoryBuilder = MemoryBuilder;
+declare const index$6_MemoryBuilder: typeof MemoryBuilder;
+type index$6_MemoryIndex = MemoryIndex;
+type index$6_Registers = Registers;
+declare const index$6_Registers: typeof Registers;
+type index$6_SbrkIndex = SbrkIndex;
+declare const index$6_gasCounter: typeof gasCounter;
+declare const index$6_logger: typeof logger;
+declare const index$6_tryAsMemoryIndex: typeof tryAsMemoryIndex;
+declare const index$6_tryAsSbrkIndex: typeof tryAsSbrkIndex;
+declare namespace index$6 {
+  export { index$6_Interpreter as Interpreter, index$6_Memory as Memory, index$6_MemoryBuilder as MemoryBuilder, index$6_Registers as Registers, index$6_gasCounter as gasCounter, index$6_logger as logger, index$6_tryAsMemoryIndex as tryAsMemoryIndex, index$6_tryAsSbrkIndex as tryAsSbrkIndex };
+  export type { index$6_InterpreterOptions as InterpreterOptions, index$6_MemoryIndex as MemoryIndex, index$6_SbrkIndex as SbrkIndex };
+}
 
+type ResolveFn = (pvm: IPvmInterpreter) => void;
+
+// TODO [MaSo] Delete this & also make host calls independent from intepreters.
 declare class InterpreterInstanceManager {
-  private instances: Interpreter[] = [];
   private waitingQueue: ResolveFn[] = [];
 
-  constructor(noOfPvmInstances: number) {
-    for (let i = 0; i < noOfPvmInstances; i++) {
-      this.instances.push(
-        new Interpreter({
-          useSbrkGas: false,
-        }),
-      );
+  private constructor(private readonly instances: IPvmInterpreter[]) {}
+
+  static async new(interpreter: PvmBackend): Promise<InterpreterInstanceManager> {
+    const instances: IPvmInterpreter[] = [];
+    switch (interpreter) {
+      case PvmBackend.BuiltIn:
+        instances.push(
+          new Interpreter({
+            useSbrkGas: false,
+          }),
+        );
+        break;
+      case PvmBackend.Ananas:
+        instances.push(await AnanasInterpreter.new());
+        break;
+      default:
+        assertNever(interpreter);
     }
+    return new InterpreterInstanceManager(instances);
   }
 
-  async getInstance(): Promise<Interpreter> {
+  async getInstance(): Promise<IPvmInterpreter> {
     const instance = this.instances.pop();
     if (instance !== undefined) {
       return Promise.resolve(instance);
@@ -18077,7 +18519,7 @@ declare class InterpreterInstanceManager {
     });
   }
 
-  releaseInstance(pvm: Interpreter) {
+  releaseInstance(pvm: IPvmInterpreter) {
     const waiting = this.waitingQueue.shift();
     if (waiting !== undefined) {
       return waiting(pvm);
@@ -18120,21 +18562,22 @@ declare class HostCalls {
     private hostCalls: HostCallsManager,
   ) {}
 
-  private getReturnValue(status: Status, pvmInstance: Interpreter): ReturnValue {
-    const gasConsumed = pvmInstance.getGasConsumed();
+  private getReturnValue(status: Status, pvmInstance: IPvmInterpreter): ReturnValue {
+    const gasConsumed = pvmInstance.gas.used();
     if (status === Status.OOG) {
       return ReturnValue.fromStatus(gasConsumed, status);
     }
 
     if (status === Status.HALT) {
-      const memory = pvmInstance.getMemory();
-      const regs = pvmInstance.getRegisters();
-      const maybeAddress = regs.getLowerU32(7);
-      const maybeLength = regs.getLowerU32(8);
+      const regs = new HostCallRegisters(pvmInstance.registers.getAllEncoded());
+      const memory = new HostCallMemory(pvmInstance.memory);
+      const address = regs.get(7);
+      // NOTE we are taking the the lower U32 part of the register, hence it's safe.
+      const length = Number(regs.get(8) & 0xffff_ffffn);
+
+      const result = safeAllocUint8Array(length);
 
-      const result = safeAllocUint8Array(maybeLength);
-      const startAddress = tryAsMemoryIndex(maybeAddress);
-      const loadResult = memory.loadInto(result, startAddress);
+      const loadResult = memory.loadInto(result, address);
 
       if (loadResult.isError) {
         return ReturnValue.fromMemorySlice(gasConsumed, new Uint8Array());
@@ -18146,7 +18589,7 @@ declare class HostCalls {
     return ReturnValue.fromStatus(gasConsumed, Status.PANIC);
   }
 
-  private async execute(pvmInstance: Interpreter) {
+  private async execute(pvmInstance: IPvmInterpreter) {
     pvmInstance.runProgram();
     for (;;) {
       let status = pvmInstance.getStatus();
@@ -18158,9 +18601,9 @@ declare class HostCalls {
         "We know that the exit param is not null, because the status is 'Status.HOST'
       `;
       const hostCallIndex = pvmInstance.getExitParam() ?? -1;
-      const gas = pvmInstance.getGasCounter();
-      const regs = new HostCallRegisters(pvmInstance.getRegisters());
-      const memory = new HostCallMemory(pvmInstance.getMemory());
+      const gas = pvmInstance.gas;
+      const regs = new HostCallRegisters(pvmInstance.registers.getAllEncoded());
+      const memory = new HostCallMemory(pvmInstance.memory);
       const index = tryAsHostCallIndex(hostCallIndex);
 
       const hostCall = this.hostCalls.get(index);
@@ -18173,7 +18616,7 @@ declare class HostCalls {
       const pcLog = `[PC: ${pvmInstance.getPC()}]`;
       if (underflow) {
         this.hostCalls.traceHostCall(`${pcLog} OOG`, index, hostCall, regs, gas.get());
-        return ReturnValue.fromStatus(pvmInstance.getGasConsumed(), Status.OOG);
+        return ReturnValue.fromStatus(gas.used(), Status.OOG);
       }
       this.hostCalls.traceHostCall(`${pcLog} Invoking`, index, hostCall, regs, gasBefore);
       const result = await hostCall.execute(gas, regs, memory);
@@ -18184,6 +18627,7 @@ declare class HostCalls {
         regs,
         gas.get(),
       );
+      pvmInstance.registers.setAllEncoded(regs.getEncoded());
 
       if (result === PvmExecution.Halt) {
         status = Status.HALT;
@@ -18210,15 +18654,9 @@ declare class HostCalls {
     }
   }
 
-  async runProgram(
-    rawProgram: Uint8Array,
-    initialPc: number,
-    initialGas: Gas,
-    maybeRegisters?: Registers,
-    maybeMemory?: Memory,
-  ): Promise<ReturnValue> {
+  async runProgram(program: Uint8Array, args: Uint8Array, initialPc: number, initialGas: Gas): Promise<ReturnValue> {
     const pvmInstance = await this.pvmInstanceManager.getInstance();
-    pvmInstance.reset(rawProgram, initialPc, initialGas, maybeRegisters, maybeMemory);
+    pvmInstance.resetJam(program, args, initialPc, initialGas);
     try {
       return await this.execute(pvmInstance);
     } finally {
@@ -18227,20 +18665,18 @@ declare class HostCalls {
   }
 }
 
-type index$7_HostCallHandler = HostCallHandler;
-type index$7_HostCallMemory = HostCallMemory;
-declare const index$7_HostCallMemory: typeof HostCallMemory;
-type index$7_HostCallRegisters = HostCallRegisters;
-declare const index$7_HostCallRegisters: typeof HostCallRegisters;
-type index$7_IHostCallMemory = IHostCallMemory;
-type index$7_IHostCallRegisters = IHostCallRegisters;
-type index$7_PvmExecution = PvmExecution;
-declare const index$7_PvmExecution: typeof PvmExecution;
-declare const index$7_traceRegisters: typeof traceRegisters;
-declare const index$7_tryAsHostCallIndex: typeof tryAsHostCallIndex;
-declare namespace index$7 {
-  export { index$7_HostCallMemory as HostCallMemory, index$7_HostCallRegisters as HostCallRegisters, HostCallsManager as HostCalls, index$7_PvmExecution as PvmExecution, HostCalls as PvmHostCallExtension, InterpreterInstanceManager as PvmInstanceManager, index$7_traceRegisters as traceRegisters, index$7_tryAsHostCallIndex as tryAsHostCallIndex };
-  export type { index$7_HostCallHandler as HostCallHandler, index$7_IHostCallMemory as IHostCallMemory, index$7_IHostCallRegisters as IHostCallRegisters };
+type index$5_HostCallHandler = HostCallHandler;
+type index$5_HostCallMemory = HostCallMemory;
+declare const index$5_HostCallMemory: typeof HostCallMemory;
+type index$5_HostCallRegisters = HostCallRegisters;
+declare const index$5_HostCallRegisters: typeof HostCallRegisters;
+type index$5_PvmExecution = PvmExecution;
+declare const index$5_PvmExecution: typeof PvmExecution;
+declare const index$5_traceRegisters: typeof traceRegisters;
+declare const index$5_tryAsHostCallIndex: typeof tryAsHostCallIndex;
+declare namespace index$5 {
+  export { index$5_HostCallMemory as HostCallMemory, index$5_HostCallRegisters as HostCallRegisters, HostCallsManager as HostCalls, index$5_PvmExecution as PvmExecution, HostCalls as PvmHostCallExtension, InterpreterInstanceManager as PvmInstanceManager, index$5_traceRegisters as traceRegisters, index$5_tryAsHostCallIndex as tryAsHostCallIndex };
+  export type { index$5_HostCallHandler as HostCallHandler };
 }
 
 /**
@@ -18258,7 +18694,7 @@ type MachineId = Opaque<U64, "MachineId[u64]">;
 declare const tryAsMachineId = (v: number | bigint): MachineId => asOpaqueType(tryAsU64(v));
 
 declare class MachineInstance {
-  async run(gas: BigGas, registers: Registers): Promise<MachineResult> {
+  async run(gas: BigGas, registers: HostCallRegisters): Promise<MachineResult> {
     return {
       result: {
         status: Status.OK,
@@ -18286,7 +18722,7 @@ type MachineStatus =
 type MachineResult = {
   result: MachineStatus;
   gas: BigGas;
-  registers: Registers;
+  registers: HostCallRegisters;
 };
 
 /** Types of possbile operations to request by Pages host call. */
@@ -18358,7 +18794,7 @@ interface RefineExternalities {
     destinationStart: U64,
     sourceStart: U64,
     length: U64,
-    destination: IHostCallMemory,
+    destination: HostCallMemory,
   ): Promise<Result$2<OK, PeekPokeError>>;
 
   /** Write a fragment of memory into `machineIndex` from given source memory. */
@@ -18367,7 +18803,7 @@ interface RefineExternalities {
     sourceStart: U64,
     destinationStart: U64,
     length: U64,
-    source: IHostCallMemory,
+    source: HostCallMemory,
   ): Promise<Result$2<OK, PeekPokeError>>;
 
   /** Start an inner PVM instance with given entry point and starting code. */
@@ -18377,7 +18813,7 @@ interface RefineExternalities {
   machineInvoke(
     machineIndex: MachineId,
     gas: BigGas,
-    registers: Registers,
+    registers: HostCallRegisters,
   ): Promise<Result$2<MachineResult, NoMachineError>>;
 
   /**
@@ -18799,7 +19235,7 @@ declare const CURRENT_SERVICE_ID = tryAsServiceId(2 ** 32 - 1);
 
 declare function getServiceIdOrCurrent(
   regNumber: number,
-  regs: IHostCallRegisters,
+  regs: HostCallRegisters,
   currentServiceId: ServiceId,
 ): ServiceId | null {
   const regValue = regs.get(regNumber);
@@ -18830,270 +19266,75 @@ declare function clampU64ToU32(value: U64): U32 {
   return value > MAX_U32_BIG_INT ? MAX_U32 : tryAsU32(Number(value));
 }
 
-type index$6_AccumulationStateUpdate = AccumulationStateUpdate;
-declare const index$6_AccumulationStateUpdate: typeof AccumulationStateUpdate;
-declare const index$6_CURRENT_SERVICE_ID: typeof CURRENT_SERVICE_ID;
-type index$6_EjectError = EjectError;
-declare const index$6_EjectError: typeof EjectError;
-type index$6_ForgetPreimageError = ForgetPreimageError;
-declare const index$6_ForgetPreimageError: typeof ForgetPreimageError;
-declare const index$6_HostCallResult: typeof HostCallResult;
-type index$6_InsufficientFundsError = InsufficientFundsError;
-declare const index$6_MAX_U32: typeof MAX_U32;
-declare const index$6_MAX_U32_BIG_INT: typeof MAX_U32_BIG_INT;
-type index$6_MachineId = MachineId;
-type index$6_MachineInstance = MachineInstance;
-declare const index$6_MachineInstance: typeof MachineInstance;
-type index$6_MachineResult = MachineResult;
-type index$6_MachineStatus = MachineStatus;
-type index$6_MemoryOperation = MemoryOperation;
-declare const index$6_MemoryOperation: typeof MemoryOperation;
-type index$6_NewServiceError = NewServiceError;
-declare const index$6_NewServiceError: typeof NewServiceError;
-type index$6_NoMachineError = NoMachineError;
-type index$6_PagesError = PagesError;
-declare const index$6_PagesError: typeof PagesError;
-type index$6_PartialState = PartialState;
-type index$6_PartiallyUpdatedState<T extends StateSlice = StateSlice> = PartiallyUpdatedState<T>;
-declare const index$6_PartiallyUpdatedState: typeof PartiallyUpdatedState;
-type index$6_PeekPokeError = PeekPokeError;
-declare const index$6_PeekPokeError: typeof PeekPokeError;
-type index$6_PendingTransfer = PendingTransfer;
-declare const index$6_PendingTransfer: typeof PendingTransfer;
-type index$6_PreimageStatus = PreimageStatus;
-type index$6_PreimageStatusKind = PreimageStatusKind;
-declare const index$6_PreimageStatusKind: typeof PreimageStatusKind;
-type index$6_ProgramCounter = ProgramCounter;
-type index$6_ProvidePreimageError = ProvidePreimageError;
-declare const index$6_ProvidePreimageError: typeof ProvidePreimageError;
-type index$6_RefineExternalities = RefineExternalities;
-type index$6_RequestPreimageError = RequestPreimageError;
-declare const index$6_RequestPreimageError: typeof RequestPreimageError;
-declare const index$6_SERVICE_ID_BYTES: typeof SERVICE_ID_BYTES;
-type index$6_SegmentExportError = SegmentExportError;
-type index$6_ServiceStateUpdate = ServiceStateUpdate;
-type index$6_StateSlice = StateSlice;
-type index$6_TRANSFER_MEMO_BYTES = TRANSFER_MEMO_BYTES;
-type index$6_TransferError = TransferError;
-declare const index$6_TransferError: typeof TransferError;
-type index$6_UnprivilegedError = UnprivilegedError;
-type index$6_UpdatePrivilegesError = UpdatePrivilegesError;
-declare const index$6_UpdatePrivilegesError: typeof UpdatePrivilegesError;
-type index$6_ZeroVoidError = ZeroVoidError;
-declare const index$6_ZeroVoidError: typeof ZeroVoidError;
-declare const index$6_clampU64ToU32: typeof clampU64ToU32;
-declare const index$6_deepCloneMapWithArray: typeof deepCloneMapWithArray;
-declare const index$6_getServiceId: typeof getServiceId;
-declare const index$6_getServiceIdOrCurrent: typeof getServiceIdOrCurrent;
-declare const index$6_preimageLenAsU32: typeof preimageLenAsU32;
-declare const index$6_slotsToPreimageStatus: typeof slotsToPreimageStatus;
-declare const index$6_toMemoryOperation: typeof toMemoryOperation;
-declare const index$6_tryAsMachineId: typeof tryAsMachineId;
-declare const index$6_tryAsProgramCounter: typeof tryAsProgramCounter;
-declare const index$6_writeServiceIdAsLeBytes: typeof writeServiceIdAsLeBytes;
-declare namespace index$6 {
-  export { index$6_AccumulationStateUpdate as AccumulationStateUpdate, index$6_CURRENT_SERVICE_ID as CURRENT_SERVICE_ID, index$6_EjectError as EjectError, index$6_ForgetPreimageError as ForgetPreimageError, index$6_HostCallResult as HostCallResult, index$6_MAX_U32 as MAX_U32, index$6_MAX_U32_BIG_INT as MAX_U32_BIG_INT, index$6_MachineInstance as MachineInstance, index$6_MemoryOperation as MemoryOperation, index$6_NewServiceError as NewServiceError, index$6_PagesError as PagesError, index$6_PartiallyUpdatedState as PartiallyUpdatedState, index$6_PeekPokeError as PeekPokeError, index$6_PendingTransfer as PendingTransfer, index$6_PreimageStatusKind as PreimageStatusKind, index$6_ProvidePreimageError as ProvidePreimageError, index$6_RequestPreimageError as RequestPreimageError, index$6_SERVICE_ID_BYTES as SERVICE_ID_BYTES, index$6_TransferError as TransferError, index$6_UpdatePrivilegesError as UpdatePrivilegesError, index$6_ZeroVoidError as ZeroVoidError, index$6_clampU64ToU32 as clampU64ToU32, index$6_deepCloneMapWithArray as deepCloneMapWithArray, index$6_getServiceId as getServiceId, index$6_getServiceIdOrCurrent as getServiceIdOrCurrent, index$6_preimageLenAsU32 as preimageLenAsU32, index$6_slotsToPreimageStatus as slotsToPreimageStatus, index$6_toMemoryOperation as toMemoryOperation, index$6_tryAsMachineId as tryAsMachineId, index$6_tryAsProgramCounter as tryAsProgramCounter, index$6_writeServiceIdAsLeBytes as writeServiceIdAsLeBytes };
-  export type { index$6_InsufficientFundsError as InsufficientFundsError, index$6_MachineId as MachineId, index$6_MachineResult as MachineResult, index$6_MachineStatus as MachineStatus, index$6_NoMachineError as NoMachineError, index$6_PartialState as PartialState, index$6_PreimageStatus as PreimageStatus, index$6_ProgramCounter as ProgramCounter, index$6_RefineExternalities as RefineExternalities, index$6_SegmentExportError as SegmentExportError, index$6_ServiceStateUpdate as ServiceStateUpdate, index$6_StateSlice as StateSlice, index$6_TRANSFER_MEMO_BYTES as TRANSFER_MEMO_BYTES, index$6_UnprivilegedError as UnprivilegedError };
-}
-
-declare const NO_OF_REGISTERS = 13;
-
-declare class MemorySegment extends WithDebug {
-  static from({ start, end, data }: Omit<MemorySegment, never>) {
-    return new MemorySegment(start, end, data);
-  }
-
-  constructor(
-    public readonly start: number,
-    public readonly end: number,
-    public readonly data: Uint8Array | null,
-  ) {
-    super();
-  }
-}
-declare class SpiMemory extends WithDebug {
-  constructor(
-    public readonly readable: MemorySegment[],
-    public readonly writeable: MemorySegment[],
-    public readonly sbrkIndex: number,
-    public readonly heapEnd: number,
-  ) {
-    super();
-  }
-}
-
-declare class SpiProgram extends WithDebug {
-  constructor(
-    public readonly code: Uint8Array,
-    public readonly memory: SpiMemory,
-    public readonly registers: BigUint64Array,
-  ) {
-    super();
-  }
-}
-
-/**
- * program = E_3(|o|) ++ E_3(|w|) ++ E_2(z) ++ E_3(s) ++ o ++ w ++ E_4(|c|) ++ c
- *
- * E_n - little endian encoding, n - length
- * o - initial read only data
- * w - initial heap
- * z - heap pages filled with zeros
- * s - stack size
- * c - program code
- *
- * https://graypaper.fluffylabs.dev/#/579bd12/2b92022b9202
- */
-declare function decodeStandardProgram(program: Uint8Array, args: Uint8Array) {
-  const decoder = Decoder.fromBlob(program);
-  const oLength = decoder.u24();
-  const wLength = decoder.u24();
-  check`${args.length <= DATA_LENGTH} Incorrect arguments length`;
-  check`${oLength <= DATA_LENGTH} Incorrect readonly segment length`;
-  const readOnlyLength = oLength;
-  check`${wLength <= DATA_LENGTH} Incorrect heap segment length`;
-  const heapLength = wLength;
-  const noOfHeapZerosPages = decoder.u16();
-  const stackSize = decoder.u24();
-  const readOnlyMemory = decoder.bytes(readOnlyLength).raw;
-  const initialHeap = decoder.bytes(heapLength).raw;
-  const codeLength = decoder.u32();
-  const code = decoder.bytes(codeLength).raw;
-  decoder.finish();
-
-  const readonlyDataStart = SEGMENT_SIZE;
-  const readonlyDataEnd = SEGMENT_SIZE + alignToPageSize(readOnlyLength);
-  const heapDataStart = 2 * SEGMENT_SIZE + alignToSegmentSize(readOnlyLength);
-  const heapDataEnd = heapDataStart + alignToPageSize(heapLength);
-  const heapZerosEnd = heapDataStart + alignToPageSize(heapLength) + noOfHeapZerosPages * PAGE_SIZE;
-  const stackStart = STACK_SEGMENT - alignToPageSize(stackSize);
-  const stackEnd = STACK_SEGMENT;
-  const argsStart = ARGS_SEGMENT;
-  const argsEnd = argsStart + alignToPageSize(args.length);
-  const argsZerosEnd = argsEnd + alignToPageSize(args.length);
-
-  function nonEmpty(s: MemorySegment | false): s is MemorySegment {
-    return s !== false;
-  }
-
-  const readableMemory = [
-    readOnlyLength > 0 && getMemorySegment(readonlyDataStart, readonlyDataEnd, readOnlyMemory),
-    args.length > 0 && getMemorySegment(argsStart, argsEnd, args),
-    argsEnd < argsZerosEnd && getMemorySegment(argsEnd, argsZerosEnd),
-  ].filter(nonEmpty);
-  const writeableMemory = [
-    heapLength > 0 && getMemorySegment(heapDataStart, heapDataEnd, initialHeap),
-    heapDataEnd < heapZerosEnd && getMemorySegment(heapDataEnd, heapZerosEnd),
-    stackStart < stackEnd && getMemorySegment(stackStart, stackEnd),
-  ].filter(nonEmpty);
-
-  return new SpiProgram(
-    code,
-    new SpiMemory(readableMemory, writeableMemory, heapZerosEnd, stackStart),
-    getRegisters(args.length),
-  );
-}
-
-declare function getMemorySegment(start: number, end: number, data: Uint8Array | null = null) {
-  return new MemorySegment(start, end, data);
-}
-
-declare function getRegisters(argsLength: number) {
-  const regs = new BigUint64Array(NO_OF_REGISTERS);
-
-  // GP reference: https://graypaper.fluffylabs.dev/#/579bd12/2c7c012cb101
-  regs[0] = BigInt(LAST_PAGE);
-  regs[1] = BigInt(STACK_SEGMENT);
-  regs[7] = BigInt(ARGS_SEGMENT);
-  regs[8] = BigInt(argsLength);
-
-  return regs;
-}
-
-type index$5_MemorySegment = MemorySegment;
-declare const index$5_MemorySegment: typeof MemorySegment;
-declare const index$5_NO_OF_REGISTERS: typeof NO_OF_REGISTERS;
-type index$5_SpiMemory = SpiMemory;
-declare const index$5_SpiMemory: typeof SpiMemory;
-type index$5_SpiProgram = SpiProgram;
-declare const index$5_SpiProgram: typeof SpiProgram;
-declare const index$5_decodeStandardProgram: typeof decodeStandardProgram;
-declare const index$5_getMemorySegment: typeof getMemorySegment;
-declare const index$5_getRegisters: typeof getRegisters;
-declare namespace index$5 {
-  export {
-    index$5_MemorySegment as MemorySegment,
-    index$5_NO_OF_REGISTERS as NO_OF_REGISTERS,
-    index$5_SpiMemory as SpiMemory,
-    index$5_SpiProgram as SpiProgram,
-    index$5_decodeStandardProgram as decodeStandardProgram,
-    index$5_getMemorySegment as getMemorySegment,
-    index$5_getRegisters as getRegisters,
-  };
-}
-
-declare class Program {
-  static fromSpi(blob: Uint8Array, args: Uint8Array, hasMetadata: boolean) {
-    const { code: spiCode, metadata } = hasMetadata ? extractCodeAndMetadata(blob) : { code: blob };
-    const { code, memory: rawMemory, registers } = decodeStandardProgram(spiCode, args);
-    const regs = new Registers();
-    regs.copyFrom(registers);
-    const memoryBuilder = new MemoryBuilder();
-
-    for (const { start, end, data } of rawMemory.readable) {
-      const startIndex = tryAsMemoryIndex(start);
-      const endIndex = tryAsMemoryIndex(end);
-      memoryBuilder.setReadablePages(startIndex, endIndex, data ?? new Uint8Array());
-    }
-
-    for (const { start, end, data } of rawMemory.writeable) {
-      const startIndex = tryAsMemoryIndex(start);
-      const endIndex = tryAsMemoryIndex(end);
-      memoryBuilder.setWriteablePages(startIndex, endIndex, data ?? new Uint8Array());
-    }
-
-    const heapStart = tryAsMemoryIndex(rawMemory.sbrkIndex);
-    const heapEnd = tryAsSbrkIndex(rawMemory.heapEnd);
-    const memory = memoryBuilder.finalize(heapStart, heapEnd);
-
-    return new Program(code, regs, memory, metadata);
-  }
-
-  static fromGeneric(blob: Uint8Array, hasMetadata: boolean) {
-    const { code, metadata } = hasMetadata ? extractCodeAndMetadata(blob) : { code: blob };
-    const regs = new Registers();
-    const memory = new Memory();
-    return new Program(code, regs, memory, metadata);
-  }
-
-  private constructor(
-    public readonly code: Uint8Array,
-    public readonly registers: Registers,
-    public readonly memory: Memory,
-    public metadata: Uint8Array = new Uint8Array(),
-  ) {}
-}
-
-/**
- * A function that splits preimage into metadata and code.
- *
- * https://graypaper.fluffylabs.dev/#/cc517d7/109a01109a01?v=0.6.5
- */
-declare function extractCodeAndMetadata(blobWithMetadata: Uint8Array) {
-  const decoder = Decoder.fromBlob(blobWithMetadata);
-  const metadata = decoder.bytesBlob().raw;
-  const code = decoder.remainingBytes().raw;
-  return { metadata, code };
-}
-
-type index$4_Program = Program;
-declare const index$4_Program: typeof Program;
-declare const index$4_extractCodeAndMetadata: typeof extractCodeAndMetadata;
+declare function emptyRegistersBuffer(): Uint8Array {
+  return safeAllocUint8Array(NO_OF_REGISTERS * REGISTER_BYTE_SIZE);
+}
+
+type index$4_AccumulationStateUpdate = AccumulationStateUpdate;
+declare const index$4_AccumulationStateUpdate: typeof AccumulationStateUpdate;
+declare const index$4_CURRENT_SERVICE_ID: typeof CURRENT_SERVICE_ID;
+type index$4_EjectError = EjectError;
+declare const index$4_EjectError: typeof EjectError;
+type index$4_ForgetPreimageError = ForgetPreimageError;
+declare const index$4_ForgetPreimageError: typeof ForgetPreimageError;
+declare const index$4_HostCallResult: typeof HostCallResult;
+type index$4_InsufficientFundsError = InsufficientFundsError;
+declare const index$4_MAX_U32: typeof MAX_U32;
+declare const index$4_MAX_U32_BIG_INT: typeof MAX_U32_BIG_INT;
+type index$4_MachineId = MachineId;
+type index$4_MachineInstance = MachineInstance;
+declare const index$4_MachineInstance: typeof MachineInstance;
+type index$4_MachineResult = MachineResult;
+type index$4_MachineStatus = MachineStatus;
+type index$4_MemoryOperation = MemoryOperation;
+declare const index$4_MemoryOperation: typeof MemoryOperation;
+type index$4_NewServiceError = NewServiceError;
+declare const index$4_NewServiceError: typeof NewServiceError;
+type index$4_NoMachineError = NoMachineError;
+type index$4_PagesError = PagesError;
+declare const index$4_PagesError: typeof PagesError;
+type index$4_PartialState = PartialState;
+type index$4_PartiallyUpdatedState<T extends StateSlice = StateSlice> = PartiallyUpdatedState<T>;
+declare const index$4_PartiallyUpdatedState: typeof PartiallyUpdatedState;
+type index$4_PeekPokeError = PeekPokeError;
+declare const index$4_PeekPokeError: typeof PeekPokeError;
+type index$4_PendingTransfer = PendingTransfer;
+declare const index$4_PendingTransfer: typeof PendingTransfer;
+type index$4_PreimageStatus = PreimageStatus;
+type index$4_PreimageStatusKind = PreimageStatusKind;
+declare const index$4_PreimageStatusKind: typeof PreimageStatusKind;
+type index$4_ProgramCounter = ProgramCounter;
+type index$4_ProvidePreimageError = ProvidePreimageError;
+declare const index$4_ProvidePreimageError: typeof ProvidePreimageError;
+type index$4_RefineExternalities = RefineExternalities;
+type index$4_RequestPreimageError = RequestPreimageError;
+declare const index$4_RequestPreimageError: typeof RequestPreimageError;
+declare const index$4_SERVICE_ID_BYTES: typeof SERVICE_ID_BYTES;
+type index$4_SegmentExportError = SegmentExportError;
+type index$4_ServiceStateUpdate = ServiceStateUpdate;
+type index$4_StateSlice = StateSlice;
+type index$4_TRANSFER_MEMO_BYTES = TRANSFER_MEMO_BYTES;
+type index$4_TransferError = TransferError;
+declare const index$4_TransferError: typeof TransferError;
+type index$4_UnprivilegedError = UnprivilegedError;
+type index$4_UpdatePrivilegesError = UpdatePrivilegesError;
+declare const index$4_UpdatePrivilegesError: typeof UpdatePrivilegesError;
+type index$4_ZeroVoidError = ZeroVoidError;
+declare const index$4_ZeroVoidError: typeof ZeroVoidError;
+declare const index$4_clampU64ToU32: typeof clampU64ToU32;
+declare const index$4_deepCloneMapWithArray: typeof deepCloneMapWithArray;
+declare const index$4_emptyRegistersBuffer: typeof emptyRegistersBuffer;
+declare const index$4_getServiceId: typeof getServiceId;
+declare const index$4_getServiceIdOrCurrent: typeof getServiceIdOrCurrent;
+declare const index$4_preimageLenAsU32: typeof preimageLenAsU32;
+declare const index$4_slotsToPreimageStatus: typeof slotsToPreimageStatus;
+declare const index$4_toMemoryOperation: typeof toMemoryOperation;
+declare const index$4_tryAsMachineId: typeof tryAsMachineId;
+declare const index$4_tryAsProgramCounter: typeof tryAsProgramCounter;
+declare const index$4_writeServiceIdAsLeBytes: typeof writeServiceIdAsLeBytes;
 declare namespace index$4 {
-  export {
-    index$4_Program as Program,
-    index$4_extractCodeAndMetadata as extractCodeAndMetadata,
-  };
+  export { index$4_AccumulationStateUpdate as AccumulationStateUpdate, index$4_CURRENT_SERVICE_ID as CURRENT_SERVICE_ID, index$4_EjectError as EjectError, index$4_ForgetPreimageError as ForgetPreimageError, index$4_HostCallResult as HostCallResult, index$4_MAX_U32 as MAX_U32, index$4_MAX_U32_BIG_INT as MAX_U32_BIG_INT, index$4_MachineInstance as MachineInstance, index$4_MemoryOperation as MemoryOperation, index$4_NewServiceError as NewServiceError, index$4_PagesError as PagesError, index$4_PartiallyUpdatedState as PartiallyUpdatedState, index$4_PeekPokeError as PeekPokeError, index$4_PendingTransfer as PendingTransfer, index$4_PreimageStatusKind as PreimageStatusKind, index$4_ProvidePreimageError as ProvidePreimageError, index$4_RequestPreimageError as RequestPreimageError, index$4_SERVICE_ID_BYTES as SERVICE_ID_BYTES, index$4_TransferError as TransferError, index$4_UpdatePrivilegesError as UpdatePrivilegesError, index$4_ZeroVoidError as ZeroVoidError, index$4_clampU64ToU32 as clampU64ToU32, index$4_deepCloneMapWithArray as deepCloneMapWithArray, index$4_emptyRegistersBuffer as emptyRegistersBuffer, index$4_getServiceId as getServiceId, index$4_getServiceIdOrCurrent as getServiceIdOrCurrent, index$4_preimageLenAsU32 as preimageLenAsU32, index$4_slotsToPreimageStatus as slotsToPreimageStatus, index$4_toMemoryOperation as toMemoryOperation, index$4_tryAsMachineId as tryAsMachineId, index$4_tryAsProgramCounter as tryAsProgramCounter, index$4_writeServiceIdAsLeBytes as writeServiceIdAsLeBytes };
+  export type { index$4_InsufficientFundsError as InsufficientFundsError, index$4_MachineId as MachineId, index$4_MachineResult as MachineResult, index$4_MachineStatus as MachineStatus, index$4_NoMachineError as NoMachineError, index$4_PartialState as PartialState, index$4_PreimageStatus as PreimageStatus, index$4_ProgramCounter as ProgramCounter, index$4_RefineExternalities as RefineExternalities, index$4_SegmentExportError as SegmentExportError, index$4_ServiceStateUpdate as ServiceStateUpdate, index$4_StateSlice as StateSlice, index$4_TRANSFER_MEMO_BYTES as TRANSFER_MEMO_BYTES, index$4_UnprivilegedError as UnprivilegedError };
 }
 
 declare class DebuggerAdapter {
@@ -19109,11 +19350,11 @@ declare class DebuggerAdapter {
   }
 
   resetGeneric(rawProgram: Uint8Array, flatRegisters: Uint8Array, initialGas: bigint) {
-    this.pvm.reset(rawProgram, 0, tryAsGas(initialGas), new Registers(flatRegisters));
+    this.pvm.resetGeneric(rawProgram, 0, tryAsGas(initialGas), new Registers(flatRegisters));
   }
 
   reset(rawProgram: Uint8Array, pc: number, gas: bigint, maybeRegisters?: Registers, maybeMemory?: Memory) {
-    this.pvm.reset(rawProgram, pc, tryAsGas(gas), maybeRegisters, maybeMemory);
+    this.pvm.resetGeneric(rawProgram, pc, tryAsGas(gas), maybeRegisters, maybeMemory);
   }
 
   getPageDump(pageNumber: number): null | Uint8Array {
@@ -19136,7 +19377,7 @@ declare class DebuggerAdapter {
   }
 
   setMemory(address: number, value: Uint8Array) {
-    this.pvm.getMemory().storeFrom(tryAsMemoryIndex(address), value);
+    this.pvm.memory.storeFrom(tryAsMemoryIndex(address), value);
   }
 
   getExitArg(): number {
@@ -19163,11 +19404,11 @@ declare class DebuggerAdapter {
   }
 
   getRegisters(): BigUint64Array {
-    return this.pvm.getRegisters().getAllU64();
+    return this.pvm.registers.getAllU64();
   }
 
   setRegisters(registers: Uint8Array) {
-    this.pvm.getRegisters().copyFrom(new Registers(registers));
+    this.pvm.registers.copyFrom(new Registers(registers));
   }
 
   getProgramCounter(): number {
@@ -19179,11 +19420,11 @@ declare class DebuggerAdapter {
   }
 
   getGasLeft(): bigint {
-    return BigInt(this.pvm.getGas());
+    return BigInt(this.pvm.gas.get());
   }
 
   setGasLeft(gas: bigint) {
-    this.pvm.getGasCounter().set(tryAsGas(gas));
+    this.pvm.gas.set(tryAsGas(gas));
   }
 }
 
@@ -19210,8 +19451,6 @@ declare const index$3_HostCallMemory: typeof HostCallMemory;
 type index$3_HostCallRegisters = HostCallRegisters;
 declare const index$3_HostCallRegisters: typeof HostCallRegisters;
 declare const index$3_HostCallResult: typeof HostCallResult;
-type index$3_IHostCallMemory = IHostCallMemory;
-type index$3_IHostCallRegisters = IHostCallRegisters;
 type index$3_ImmediateDecoder = ImmediateDecoder;
 declare const index$3_ImmediateDecoder: typeof ImmediateDecoder;
 type index$3_InsufficientFundsError = InsufficientFundsError;
@@ -19294,6 +19533,7 @@ declare const index$3_clampU64ToU32: typeof clampU64ToU32;
 declare const index$3_createResults: typeof createResults;
 declare const index$3_decodeStandardProgram: typeof decodeStandardProgram;
 declare const index$3_deepCloneMapWithArray: typeof deepCloneMapWithArray;
+declare const index$3_emptyRegistersBuffer: typeof emptyRegistersBuffer;
 declare const index$3_extractCodeAndMetadata: typeof extractCodeAndMetadata;
 declare const index$3_getServiceId: typeof getServiceId;
 declare const index$3_getServiceIdOrCurrent: typeof getServiceIdOrCurrent;
@@ -19312,8 +19552,8 @@ declare const index$3_tryAsMachineId: typeof tryAsMachineId;
 declare const index$3_tryAsProgramCounter: typeof tryAsProgramCounter;
 declare const index$3_writeServiceIdAsLeBytes: typeof writeServiceIdAsLeBytes;
 declare namespace index$3 {
-  export { index$3_AccumulationStateUpdate as AccumulationStateUpdate, index$3_ArgsDecoder as ArgsDecoder, index$3_ArgumentType as ArgumentType, index$3_BasicBlocks as BasicBlocks, index$3_CURRENT_SERVICE_ID as CURRENT_SERVICE_ID, index$3_EjectError as EjectError, index$3_ExtendedWitdthImmediateDecoder as ExtendedWitdthImmediateDecoder, index$3_ForgetPreimageError as ForgetPreimageError, index$3_HostCallMemory as HostCallMemory, index$3_HostCallRegisters as HostCallRegisters, index$3_HostCallResult as HostCallResult, index$3_ImmediateDecoder as ImmediateDecoder, index$3_MAX_U32 as MAX_U32, index$3_MAX_U32_BIG_INT as MAX_U32_BIG_INT, index$3_MachineInstance as MachineInstance, index$3_Mask as Mask, index$3_MemoryOperation as MemoryOperation, index$3_MemorySegment as MemorySegment, NO_OF_REGISTERS$1 as NO_OF_REGISTERS, index$3_NewServiceError as NewServiceError, index$3_NibblesDecoder as NibblesDecoder, index$3_PagesError as PagesError, index$3_PartiallyUpdatedState as PartiallyUpdatedState, index$3_PeekPokeError as PeekPokeError, index$3_PendingTransfer as PendingTransfer, index$3_PreimageStatusKind as PreimageStatusKind, index$3_Program as Program, index$3_ProgramDecoder as ProgramDecoder, index$3_ProvidePreimageError as ProvidePreimageError, DebuggerAdapter as Pvm, index$3_Registers as Registers, index$3_RequestPreimageError as RequestPreimageError, Result$2 as Result, index$3_RichTaggedError as RichTaggedError, index$3_SERVICE_ID_BYTES as SERVICE_ID_BYTES, index$3_SpiMemory as SpiMemory, index$3_SpiProgram as SpiProgram, index$3_TransferError as TransferError, index$3_UpdatePrivilegesError as UpdatePrivilegesError, index$3_WithDebug as WithDebug, index$3_ZeroVoidError as ZeroVoidError, index$3___OPAQUE_TYPE__ as __OPAQUE_TYPE__, index$3_asOpaqueType as asOpaqueType, index$3_assertEmpty as assertEmpty, index$3_assertNever as assertNever, index$l as block, index$s as bytes, index$3_check as check, index$3_clampU64ToU32 as clampU64ToU32, index$3_createResults as createResults, index$3_decodeStandardProgram as decodeStandardProgram, index$3_deepCloneMapWithArray as deepCloneMapWithArray, index$3_extractCodeAndMetadata as extractCodeAndMetadata, index$3_getServiceId as getServiceId, index$3_getServiceIdOrCurrent as getServiceIdOrCurrent, index$p as hash, index$3_inspect as inspect, index$3_instructionArgumentTypeMap as instructionArgumentTypeMap, index$8 as interpreter, index$3_isBrowser as isBrowser, index$3_isTaggedError as isTaggedError, index$3_maybeTaggedErrorToString as maybeTaggedErrorToString, index$3_measure as measure, index$r as numbers, index$3_preimageLenAsU32 as preimageLenAsU32, index$3_resultToString as resultToString, index$3_seeThrough as seeThrough, index$3_slotsToPreimageStatus as slotsToPreimageStatus, index$3_toMemoryOperation as toMemoryOperation, index$3_tryAsMachineId as tryAsMachineId, index$3_tryAsProgramCounter as tryAsProgramCounter, index$3_writeServiceIdAsLeBytes as writeServiceIdAsLeBytes };
-  export type { index$3_Args as Args, index$3_EnumMapping as EnumMapping, index$3_ErrorResult as ErrorResult, index$3_IHostCallMemory as IHostCallMemory, index$3_IHostCallRegisters as IHostCallRegisters, index$3_InsufficientFundsError as InsufficientFundsError, index$3_MachineId as MachineId, index$3_MachineResult as MachineResult, index$3_MachineStatus as MachineStatus, index$3_NoMachineError as NoMachineError, index$3_OK as OK, index$3_OkResult as OkResult, index$3_Opaque as Opaque, index$3_PartialState as PartialState, index$3_PreimageStatus as PreimageStatus, index$3_ProgramCounter as ProgramCounter, index$3_RefineExternalities as RefineExternalities, index$3_SegmentExportError as SegmentExportError, index$3_ServiceStateUpdate as ServiceStateUpdate, index$3_StateSlice as StateSlice, index$3_StringLiteral as StringLiteral, index$3_TRANSFER_MEMO_BYTES as TRANSFER_MEMO_BYTES, index$3_TaggedError as TaggedError, index$3_TokenOf as TokenOf, index$3_Uninstantiable as Uninstantiable, index$3_UnprivilegedError as UnprivilegedError, index$3_WithOpaque as WithOpaque };
+  export { index$3_AccumulationStateUpdate as AccumulationStateUpdate, index$3_ArgsDecoder as ArgsDecoder, index$3_ArgumentType as ArgumentType, index$3_BasicBlocks as BasicBlocks, index$3_CURRENT_SERVICE_ID as CURRENT_SERVICE_ID, index$3_EjectError as EjectError, index$3_ExtendedWitdthImmediateDecoder as ExtendedWitdthImmediateDecoder, index$3_ForgetPreimageError as ForgetPreimageError, index$3_HostCallMemory as HostCallMemory, index$3_HostCallRegisters as HostCallRegisters, index$3_HostCallResult as HostCallResult, index$3_ImmediateDecoder as ImmediateDecoder, index$3_MAX_U32 as MAX_U32, index$3_MAX_U32_BIG_INT as MAX_U32_BIG_INT, index$3_MachineInstance as MachineInstance, index$3_Mask as Mask, index$3_MemoryOperation as MemoryOperation, index$3_MemorySegment as MemorySegment, NO_OF_REGISTERS$1 as NO_OF_REGISTERS, index$3_NewServiceError as NewServiceError, index$3_NibblesDecoder as NibblesDecoder, index$3_PagesError as PagesError, index$3_PartiallyUpdatedState as PartiallyUpdatedState, index$3_PeekPokeError as PeekPokeError, index$3_PendingTransfer as PendingTransfer, index$3_PreimageStatusKind as PreimageStatusKind, index$3_Program as Program, index$3_ProgramDecoder as ProgramDecoder, index$3_ProvidePreimageError as ProvidePreimageError, DebuggerAdapter as Pvm, index$3_Registers as Registers, index$3_RequestPreimageError as RequestPreimageError, Result$2 as Result, index$3_RichTaggedError as RichTaggedError, index$3_SERVICE_ID_BYTES as SERVICE_ID_BYTES, index$3_SpiMemory as SpiMemory, index$3_SpiProgram as SpiProgram, index$3_TransferError as TransferError, index$3_UpdatePrivilegesError as UpdatePrivilegesError, index$3_WithDebug as WithDebug, index$3_ZeroVoidError as ZeroVoidError, index$3___OPAQUE_TYPE__ as __OPAQUE_TYPE__, index$3_asOpaqueType as asOpaqueType, index$3_assertEmpty as assertEmpty, index$3_assertNever as assertNever, index$l as block, index$s as bytes, index$3_check as check, index$3_clampU64ToU32 as clampU64ToU32, index$3_createResults as createResults, index$3_decodeStandardProgram as decodeStandardProgram, index$3_deepCloneMapWithArray as deepCloneMapWithArray, index$3_emptyRegistersBuffer as emptyRegistersBuffer, index$3_extractCodeAndMetadata as extractCodeAndMetadata, index$3_getServiceId as getServiceId, index$3_getServiceIdOrCurrent as getServiceIdOrCurrent, index$p as hash, index$3_inspect as inspect, index$3_instructionArgumentTypeMap as instructionArgumentTypeMap, index$6 as interpreter, index$3_isBrowser as isBrowser, index$3_isTaggedError as isTaggedError, index$3_maybeTaggedErrorToString as maybeTaggedErrorToString, index$3_measure as measure, index$r as numbers, index$3_preimageLenAsU32 as preimageLenAsU32, index$3_resultToString as resultToString, index$3_seeThrough as seeThrough, index$3_slotsToPreimageStatus as slotsToPreimageStatus, index$3_toMemoryOperation as toMemoryOperation, index$3_tryAsMachineId as tryAsMachineId, index$3_tryAsProgramCounter as tryAsProgramCounter, index$3_writeServiceIdAsLeBytes as writeServiceIdAsLeBytes };
+  export type { index$3_Args as Args, index$3_EnumMapping as EnumMapping, index$3_ErrorResult as ErrorResult, index$3_InsufficientFundsError as InsufficientFundsError, index$3_MachineId as MachineId, index$3_MachineResult as MachineResult, index$3_MachineStatus as MachineStatus, index$3_NoMachineError as NoMachineError, index$3_OK as OK, index$3_OkResult as OkResult, index$3_Opaque as Opaque, index$3_PartialState as PartialState, index$3_PreimageStatus as PreimageStatus, index$3_ProgramCounter as ProgramCounter, index$3_RefineExternalities as RefineExternalities, index$3_SegmentExportError as SegmentExportError, index$3_ServiceStateUpdate as ServiceStateUpdate, index$3_StateSlice as StateSlice, index$3_StringLiteral as StringLiteral, index$3_TRANSFER_MEMO_BYTES as TRANSFER_MEMO_BYTES, index$3_TaggedError as TaggedError, index$3_TokenOf as TokenOf, index$3_Uninstantiable as Uninstantiable, index$3_UnprivilegedError as UnprivilegedError, index$3_WithOpaque as WithOpaque };
 }
 
 declare const ENTROPY_BYTES = 32;
@@ -20205,4 +20445,4 @@ declare namespace index {
   export type { index_PreimagesInput as PreimagesInput, index_PreimagesState as PreimagesState, index_PreimagesStateUpdate as PreimagesStateUpdate };
 }
 
-export { index$l as block, index$j as block_json, index$s as bytes, index$q as codec, index$o as collections, index$m as config, index$h as config_node, index$n as crypto, index$c as database, index$b as erasure_coding, index$9 as fuzz_proto, index$p as hash, index$6 as jam_host_calls, index$k as json_parser, index$i as logger, index$f as mmr, index$r as numbers, index$t as ordering, index$3 as pvm, index$7 as pvm_host_calls, index$8 as pvm_interpreter, index$4 as pvm_program, index$5 as pvm_spi_decoder, index$2 as shuffling, index$e as state, index$1 as state_json, index$d as state_merkleization, index as transition, index$g as trie, index$u as utils };
+export { index$l as block, index$j as block_json, index$s as bytes, index$q as codec, index$o as collections, index$m as config, index$h as config_node, index$n as crypto, index$c as database, index$b as erasure_coding, index$9 as fuzz_proto, index$p as hash, index$4 as jam_host_calls, index$k as json_parser, index$i as logger, index$f as mmr, index$r as numbers, index$t as ordering, index$3 as pvm, index$5 as pvm_host_calls, index$6 as pvm_interpreter, index$7 as pvm_program, index$8 as pvm_spi_decoder, index$2 as shuffling, index$e as state, index$1 as state_json, index$d as state_merkleization, index as transition, index$g as trie, index$u as utils };