@typeberry/lib 0.2.0-0303f5b → 0.2.0-3f440a7

package/index.d.ts

@@ -2,7 +2,7 @@ declare enum GpVersion {
   V0_6_7 = "0.6.7",
   V0_7_0 = "0.7.0",
   V0_7_1 = "0.7.1",
-  V0_7_2 = "0.7.2-preview",
+  V0_7_2 = "0.7.2",
 }
 
 declare enum TestSuite {
@@ -10,43 +10,39 @@ declare enum TestSuite {
   JAMDUNA = "jamduna",
 }
 
+declare const ALL_VERSIONS_IN_ORDER = [GpVersion.V0_6_7, GpVersion.V0_7_0, GpVersion.V0_7_1, GpVersion.V0_7_2];
+
 declare const DEFAULT_SUITE = TestSuite.W3F_DAVXY;
-declare const DEFAULT_VERSION = GpVersion.V0_7_1;
+declare const DEFAULT_VERSION = GpVersion.V0_7_2;
 declare let CURRENT_VERSION = parseCurrentVersion(env.GP_VERSION) ?? DEFAULT_VERSION;
 declare let CURRENT_SUITE = parseCurrentSuite(env.TEST_SUITE) ?? DEFAULT_SUITE;
 
-declare const ALL_VERSIONS_IN_ORDER = [GpVersion.V0_6_7, GpVersion.V0_7_0, GpVersion.V0_7_1, GpVersion.V0_7_2];
-
 declare function parseCurrentVersion(env?: string): GpVersion | undefined {
   if (env === undefined) {
     return undefined;
   }
-  switch (env) {
-    case GpVersion.V0_6_7:
-    case GpVersion.V0_7_0:
-    case GpVersion.V0_7_1:
-    case GpVersion.V0_7_2:
-      return env;
-    default:
-      throw new Error(
-        `Configured environment variable GP_VERSION is unknown: '${env}'. Use one of: ${ALL_VERSIONS_IN_ORDER}`,
-      );
+  for (const v of Object.values(GpVersion)) {
+    if (env === v) {
+      return v;
+    }
   }
+  throw new Error(
+    `Configured environment variable GP_VERSION is unknown: '${env}'. Use one of: ${ALL_VERSIONS_IN_ORDER}`,
+  );
 }
 
 declare function parseCurrentSuite(env?: string): TestSuite | undefined {
   if (env === undefined) {
     return undefined;
   }
-  switch (env) {
-    case TestSuite.W3F_DAVXY:
-    case TestSuite.JAMDUNA:
-      return env;
-    default:
-      throw new Error(
-        `Configured environment variable TEST_SUITE is unknown: '${env}'. Use one of: ${Object.values(TestSuite)}`,
-      );
+  for (const s of Object.values(TestSuite)) {
+    if (env === s) {
+      return s;
+    }
   }
+  throw new Error(
+    `Configured environment variable TEST_SUITE is unknown: '${env}'. Use one of: ${Object.values(TestSuite)}`,
+  );
 }
 
 declare class Compatibility {
@@ -242,6 +238,14 @@ declare abstract class WithDebug {
   }
 }
 
+declare function lazyInspect<T>(obj: T) {
+  return {
+    toString() {
+      return inspect(obj);
+    },
+  };
+}
+
 /**
  * The function will produce relative path resolver that is adjusted
  * for package location within the workspace.
@@ -769,6 +773,7 @@ declare const index$u_inspect: typeof inspect;
 declare const index$u_isBrowser: typeof isBrowser;
 declare const index$u_isResult: typeof isResult;
 declare const index$u_isTaggedError: typeof isTaggedError;
+declare const index$u_lazyInspect: typeof lazyInspect;
 declare const index$u_maybeTaggedErrorToString: typeof maybeTaggedErrorToString;
 declare const index$u_measure: typeof measure;
 declare const index$u_oomWarningPrinted: typeof oomWarningPrinted;
@@ -780,7 +785,7 @@ declare const index$u_seeThrough: typeof seeThrough;
 declare const index$u_trimStack: typeof trimStack;
 declare const index$u_workspacePathFix: typeof workspacePathFix;
 declare namespace index$u {
-  export { index$u_ALL_VERSIONS_IN_ORDER as ALL_VERSIONS_IN_ORDER, index$u_CURRENT_SUITE as CURRENT_SUITE, index$u_CURRENT_VERSION as CURRENT_VERSION, index$u_Compatibility as Compatibility, index$u_DEFAULT_SUITE as DEFAULT_SUITE, index$u_DEFAULT_VERSION as DEFAULT_VERSION, index$u_ErrorsCollector as ErrorsCollector, index$u_GpVersion as GpVersion, MAX_LENGTH$1 as MAX_LENGTH, Result$2 as Result, index$u_RichTaggedError as RichTaggedError, index$u_TEST_COMPARE_USING as TEST_COMPARE_USING, index$u_TestSuite as TestSuite, index$u_WithDebug as WithDebug, index$u___OPAQUE_TYPE__ as __OPAQUE_TYPE__, index$u_asOpaqueType as asOpaqueType, index$u_assertEmpty as assertEmpty, index$u_assertNever as assertNever, index$u_callCompareFunction as callCompareFunction, index$u_check as check, index$u_deepEqual as deepEqual, index$u_getAllKeysSorted as getAllKeysSorted, index$u_inspect as inspect, index$u_isBrowser as isBrowser, index$u_isResult as isResult, index$u_isTaggedError as isTaggedError, index$u_maybeTaggedErrorToString as maybeTaggedErrorToString, index$u_measure as measure, index$u_oomWarningPrinted as oomWarningPrinted, index$u_parseCurrentSuite as parseCurrentSuite, index$u_parseCurrentVersion as parseCurrentVersion, index$u_resultToString as resultToString, index$u_safeAllocUint8Array as safeAllocUint8Array, index$u_seeThrough as seeThrough, index$u_trimStack as trimStack, index$u_workspacePathFix as workspacePathFix };
+  export { index$u_ALL_VERSIONS_IN_ORDER as ALL_VERSIONS_IN_ORDER, index$u_CURRENT_SUITE as CURRENT_SUITE, index$u_CURRENT_VERSION as CURRENT_VERSION, index$u_Compatibility as Compatibility, index$u_DEFAULT_SUITE as DEFAULT_SUITE, index$u_DEFAULT_VERSION as DEFAULT_VERSION, index$u_ErrorsCollector as ErrorsCollector, index$u_GpVersion as GpVersion, MAX_LENGTH$1 as MAX_LENGTH, Result$2 as Result, index$u_RichTaggedError as RichTaggedError, index$u_TEST_COMPARE_USING as TEST_COMPARE_USING, index$u_TestSuite as TestSuite, index$u_WithDebug as WithDebug, index$u___OPAQUE_TYPE__ as __OPAQUE_TYPE__, index$u_asOpaqueType as asOpaqueType, index$u_assertEmpty as assertEmpty, index$u_assertNever as assertNever, index$u_callCompareFunction as callCompareFunction, index$u_check as check, index$u_deepEqual as deepEqual, index$u_getAllKeysSorted as getAllKeysSorted, index$u_inspect as inspect, index$u_isBrowser as isBrowser, index$u_isResult as isResult, index$u_isTaggedError as isTaggedError, index$u_lazyInspect as lazyInspect, index$u_maybeTaggedErrorToString as maybeTaggedErrorToString, index$u_measure as measure, index$u_oomWarningPrinted as oomWarningPrinted, index$u_parseCurrentSuite as parseCurrentSuite, index$u_parseCurrentVersion as parseCurrentVersion, index$u_resultToString as resultToString, index$u_safeAllocUint8Array as safeAllocUint8Array, index$u_seeThrough as seeThrough, index$u_trimStack as trimStack, index$u_workspacePathFix as workspacePathFix };
   export type { index$u_DeepEqualOptions as DeepEqualOptions, index$u_EnumMapping as EnumMapping, index$u_ErrorResult as ErrorResult, index$u_OK as OK, index$u_OkResult as OkResult, index$u_Opaque as Opaque, index$u_StringLiteral as StringLiteral, index$u_TaggedError as TaggedError, index$u_TokenOf as TokenOf, index$u_Uninstantiable as Uninstantiable, index$u_WithOpaque as WithOpaque };
 }
 
@@ -5117,6 +5122,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;
@@ -5128,10 +5144,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_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_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 };
 }
 
@@ -8154,7 +8173,8 @@ declare const DEFAULT_CONFIG = "default";
 
 declare const NODE_DEFAULTS = {
   name: isBrowser() ? "browser" : os.hostname(),
-  config: DEFAULT_CONFIG,
+  config: [DEFAULT_CONFIG],
+  pvm: PvmBackend.BuiltIn,
 };
 
 /** Chain spec chooser. */
@@ -8207,52 +8227,173 @@ declare class NodeConfiguration {
   ) {}
 }
 
-declare function loadConfig(configPath: string): NodeConfiguration {
-  if (configPath === DEFAULT_CONFIG) {
-    logger.log`🔧 Loading DEFAULT config`;
-    return parseFromJson(configs.default, NodeConfiguration.fromJson);
-  }
+declare function loadConfig(config: string[], withRelPath: (p: string) => string): NodeConfiguration {
+  logger.log`🔧 Loading config`;
+  let mergedJson: AnyJsonObject = {};
+
+  for (const entry of config) {
+    logger.log`🔧 Applying '${entry}'`;
+
+    if (entry === DEV_CONFIG) {
+      mergedJson = structuredClone(configs.dev); // clone to avoid mutating the original config. not doing a merge since dev and default should theoretically replace all properties.
+      continue;
+    }
+
+    if (entry === DEFAULT_CONFIG) {
+      mergedJson = structuredClone(configs.default);
+      continue;
+    }
+
+    // try to parse as JSON
+    try {
+      const parsed = JSON.parse(entry);
+      deepMerge(mergedJson, parsed);
+      continue;
+    } catch {}
 
-  if (configPath === DEV_CONFIG) {
-    logger.log`🔧 Loading DEV config`;
-    return parseFromJson(configs.dev, NodeConfiguration.fromJson);
+    // if not, try to load as file
+    if (entry.indexOf("=") === -1 && entry.endsWith(".json")) {
+      try {
+        const configFile = fs.readFileSync(withRelPath(entry), "utf8");
+        const parsed = JSON.parse(configFile);
+        deepMerge(mergedJson, parsed);
+      } catch (e) {
+        throw new Error(`Unable to load config from ${entry}: ${e}`);
+      }
+    } else {
+      // finally try to process as a pseudo-jq query
+      try {
+        processQuery(mergedJson, entry, withRelPath);
+      } catch (e) {
+        throw new Error(`Error while processing '${entry}': ${e}`);
+      }
+    }
   }
 
   try {
-    logger.log`🔧 Loading config from ${configPath}`;
-    const configFile = fs.readFileSync(configPath, "utf8");
-    const parsed = JSON.parse(configFile);
-    return parseFromJson(parsed, NodeConfiguration.fromJson);
+    const parsed = parseFromJson(mergedJson, NodeConfiguration.fromJson);
+    logger.log`🔧 Config ready`;
+    return parsed;
   } catch (e) {
-    throw new Error(`Unable to load config file from ${configPath}: ${e}`);
+    throw new Error(`Unable to parse config: ${e}`);
+  }
+}
+
+declare function deepMerge(target: AnyJsonObject, source: JsonValue): void {
+  if (!isJsonObject(source)) {
+    throw new Error(`Expected object, got ${source}`);
+  }
+  for (const key in source) {
+    if (isJsonObject(source[key])) {
+      if (!isJsonObject(target[key])) {
+        target[key] = {};
+      }
+      deepMerge(target[key], source[key]);
+    } else {
+      target[key] = source[key];
+    }
+  }
+}
+
+/**
+ * Caution: updates input directly.
+ * Processes a pseudo-jq query. Syntax:
+ * .path.to.value = { ... } - updates value with the specified object by replacement
+ * .path.to.value += { ... } - updates value with the specified object by merging
+ * .path.to.value = file.json - updates value with the contents of file.json
+ * .path.to.value += file.json - merges the contents of file.json onto value
+ */
+declare function processQuery(input: AnyJsonObject, query: string, withRelPath: (p: string) => string): void {
+  const queryParts = query.split("=");
+
+  if (queryParts.length === 2) {
+    let [path, value] = queryParts.map((part) => part.trim());
+    let merge = false;
+
+    // detect += syntax
+    if (path.endsWith("+")) {
+      merge = true;
+      path = path.slice(0, -1);
+    }
+
+    let parsedValue: JsonValue;
+    if (value.endsWith(".json")) {
+      try {
+        const configFile = fs.readFileSync(withRelPath(value), "utf8");
+        const parsed = JSON.parse(configFile);
+        parsedValue = parsed;
+      } catch (e) {
+        throw new Error(`Unable to load config from ${value}: ${e}`);
+      }
+    } else {
+      try {
+        parsedValue = JSON.parse(value);
+      } catch (e) {
+        throw new Error(`Unrecognized syntax '${value}': ${e}`);
+      }
+    }
+
+    let pathParts = path.split(".");
+
+    // allow leading dot in path
+    if (pathParts[0] === "") {
+      pathParts = pathParts.slice(1);
+    }
+
+    let target = input;
+    for (let i = 0; i < pathParts.length; i++) {
+      const part = pathParts[i];
+      if (!isJsonObject(target[part])) {
+        target[part] = {};
+      }
+      if (i === pathParts.length - 1) {
+        if (merge) {
+          deepMerge(target[part], parsedValue);
+        } else {
+          target[part] = parsedValue;
+        }
+        return;
+      }
+      target = target[part];
+    }
   }
+
+  throw new Error("Unrecognized syntax.");
+}
+
+type JsonValue = string | number | boolean | null | AnyJsonObject | JsonArray;
+
+interface AnyJsonObject {
+  [key: string]: JsonValue;
+}
+
+interface JsonArray extends Array<JsonValue> {}
+
+declare function isJsonObject(value: JsonValue): value is AnyJsonObject {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+type index$h_AnyJsonObject = AnyJsonObject;
 declare const index$h_DEFAULT_CONFIG: typeof DEFAULT_CONFIG;
 declare const index$h_DEV_CONFIG: typeof DEV_CONFIG;
 type index$h_JipChainSpec = JipChainSpec;
 declare const index$h_JipChainSpec: typeof JipChainSpec;
+type index$h_JsonArray = JsonArray;
+type index$h_JsonValue = JsonValue;
 type index$h_KnownChainSpec = KnownChainSpec;
 declare const index$h_KnownChainSpec: typeof KnownChainSpec;
 declare const index$h_NODE_DEFAULTS: typeof NODE_DEFAULTS;
 type index$h_NodeConfiguration = NodeConfiguration;
 declare const index$h_NodeConfiguration: typeof NodeConfiguration;
+declare const index$h_deepMerge: typeof deepMerge;
+declare const index$h_isJsonObject: typeof isJsonObject;
 declare const index$h_knownChainSpecFromJson: typeof knownChainSpecFromJson;
 declare const index$h_loadConfig: typeof loadConfig;
 declare const index$h_parseBootnode: typeof parseBootnode;
+declare const index$h_processQuery: typeof processQuery;
 declare namespace index$h {
-  export {
-    index$h_DEFAULT_CONFIG as DEFAULT_CONFIG,
-    index$h_DEV_CONFIG as DEV_CONFIG,
-    index$h_JipChainSpec as JipChainSpec,
-    index$h_KnownChainSpec as KnownChainSpec,
-    index$h_NODE_DEFAULTS as NODE_DEFAULTS,
-    index$h_NodeConfiguration as NodeConfiguration,
-    index$h_knownChainSpecFromJson as knownChainSpecFromJson,
-    index$h_loadConfig as loadConfig,
-    logger$2 as logger,
-    index$h_parseBootnode as parseBootnode,
-  };
+  export { index$h_DEFAULT_CONFIG as DEFAULT_CONFIG, index$h_DEV_CONFIG as DEV_CONFIG, index$h_JipChainSpec as JipChainSpec, index$h_KnownChainSpec as KnownChainSpec, index$h_NODE_DEFAULTS as NODE_DEFAULTS, index$h_NodeConfiguration as NodeConfiguration, index$h_deepMerge as deepMerge, index$h_isJsonObject as isJsonObject, index$h_knownChainSpecFromJson as knownChainSpecFromJson, index$h_loadConfig as loadConfig, logger$2 as logger, index$h_parseBootnode as parseBootnode, index$h_processQuery as processQuery };
+  export type { index$h_AnyJsonObject as AnyJsonObject, index$h_JsonArray as JsonArray, index$h_JsonValue as JsonValue };
 }
 
 /**
@@ -9977,25 +10118,6 @@ declare class LookupHistoryItem {
   }
 }
 
-/** Dictionary entry of services that auto-accumulate every block. */
-declare class AutoAccumulate {
-  static Codec = codec.Class(AutoAccumulate, {
-    service: codec.u32.asOpaque<ServiceId>(),
-    gasLimit: codec.u64.asOpaque<ServiceGas>(),
-  });
-
-  static create({ service, gasLimit }: CodecRecord<AutoAccumulate>) {
-    return new AutoAccumulate(service, gasLimit);
-  }
-
-  private constructor(
-    /** Service id that auto-accumulates. */
-    readonly service: ServiceId,
-    /** Gas limit for auto-accumulation. */
-    readonly gasLimit: ServiceGas,
-  ) {}
-}
-
 /**
  * https://graypaper.fluffylabs.dev/#/ab2cdbd/114402114402?v=0.7.2
  */
@@ -10008,7 +10130,9 @@ declare class PrivilegedServices {
     registrar: Compatibility.isGreaterOrEqual(GpVersion.V0_7_1)
       ? codec.u32.asOpaque<ServiceId>()
       : ignoreValueWithDefault(tryAsServiceId(2 ** 32 - 1)),
-    autoAccumulateServices: readonlyArray(codec.sequenceVarLen(AutoAccumulate.Codec)),
+    autoAccumulateServices: codec.dictionary(codec.u32.asOpaque<ServiceId>(), codec.u64.asOpaque<ServiceGas>(), {
+      sortKeys: (a, b) => a - b,
+    }),
   });
 
   static create(a: CodecRecord<PrivilegedServices>) {
@@ -10033,7 +10157,7 @@ declare class PrivilegedServices {
     /** `χ_A`: Manages authorization queue one for each core. */
     readonly assigners: PerCore<ServiceId>,
     /** `χ_Z`: Dictionary of services that auto-accumulate every block with their gas limit. */
-    readonly autoAccumulateServices: readonly AutoAccumulate[],
+    readonly autoAccumulateServices: Map<ServiceId, ServiceGas>,
   ) {}
 }
 
@@ -11350,7 +11474,7 @@ declare class InMemoryState extends WithDebug implements State, WithStateView, E
         assigners: tryAsPerCore(new Array(spec.coresCount).fill(tryAsServiceId(0)), spec),
         delegator: tryAsServiceId(0),
         registrar: tryAsServiceId(MAX_VALUE),
-        autoAccumulateServices: [],
+        autoAccumulateServices: new Map(),
       }),
       accumulationOutputLog: SortedArray.fromArray(accumulationOutputComparator, []),
       services: new Map(),
@@ -11406,8 +11530,6 @@ type index$e_AccumulationQueue = AccumulationQueue;
 type index$e_AccumulationQueueView = AccumulationQueueView;
 type index$e_AuthorizationPool = AuthorizationPool;
 type index$e_AuthorizationQueue = AuthorizationQueue;
-type index$e_AutoAccumulate = AutoAccumulate;
-declare const index$e_AutoAccumulate: typeof AutoAccumulate;
 type index$e_AvailabilityAssignment = AvailabilityAssignment;
 declare const index$e_AvailabilityAssignment: typeof AvailabilityAssignment;
 type index$e_AvailabilityAssignmentsView = AvailabilityAssignmentsView;
@@ -11516,7 +11638,7 @@ declare const index$e_validatorsDataCodec: typeof validatorsDataCodec;
 declare const index$e_workReportsSortedSetCodec: typeof workReportsSortedSetCodec;
 declare const index$e_zeroSizeHint: typeof zeroSizeHint;
 declare namespace index$e {
-  export { index$e_AccumulationOutput as AccumulationOutput, index$e_AutoAccumulate as AutoAccumulate, index$e_AvailabilityAssignment as AvailabilityAssignment, index$e_BASE_SERVICE_BALANCE as BASE_SERVICE_BALANCE, index$e_BlockState as BlockState, index$e_CoreStatistics as CoreStatistics, index$e_DisputesRecords as DisputesRecords, index$e_ELECTIVE_BYTE_BALANCE as ELECTIVE_BYTE_BALANCE, index$e_ELECTIVE_ITEM_BALANCE as ELECTIVE_ITEM_BALANCE, index$e_InMemoryService as InMemoryService, index$e_InMemoryState as InMemoryState, index$e_LookupHistoryItem as LookupHistoryItem, index$e_MAX_LOOKUP_HISTORY_SLOTS as MAX_LOOKUP_HISTORY_SLOTS, index$e_NotYetAccumulatedReport as NotYetAccumulatedReport, index$e_PreimageItem as PreimageItem, index$e_PrivilegedServices as PrivilegedServices, index$e_RecentBlocks as RecentBlocks, index$e_SafroleData as SafroleData, index$e_SafroleSealingKeysData as SafroleSealingKeysData, index$e_SafroleSealingKeysKind as SafroleSealingKeysKind, index$e_ServiceAccountInfo as ServiceAccountInfo, index$e_ServiceStatistics as ServiceStatistics, index$e_StatisticsData as StatisticsData, index$e_StorageItem as StorageItem, index$e_UpdateError as UpdateError, index$e_UpdatePreimage as UpdatePreimage, index$e_UpdatePreimageKind as UpdatePreimageKind, index$e_UpdateService as UpdateService, index$e_UpdateServiceKind as UpdateServiceKind, index$e_UpdateStorage as UpdateStorage, index$e_UpdateStorageKind as UpdateStorageKind, index$e_ValidatorData as ValidatorData, index$e_ValidatorStatistics as ValidatorStatistics, index$e_accumulationOutputComparator as accumulationOutputComparator, index$e_accumulationQueueCodec as accumulationQueueCodec, index$e_authPoolsCodec as authPoolsCodec, index$e_authQueuesCodec as authQueuesCodec, index$e_availabilityAssignmentsCodec as availabilityAssignmentsCodec, index$e_codecBandersnatchKey as codecBandersnatchKey, index$e_codecPerCore as codecPerCore, index$e_codecServiceId as codecServiceId, index$e_codecVarGas as codecVarGas, index$e_codecVarU16 as codecVarU16, index$e_codecWithVersion as codecWithVersion, index$e_hashComparator as hashComparator, index$e_ignoreValueWithDefault as ignoreValueWithDefault, index$e_recentlyAccumulatedCodec as recentlyAccumulatedCodec, index$e_serviceDataCodec as serviceDataCodec, index$e_serviceEntriesCodec as serviceEntriesCodec, index$e_sortedSetCodec as sortedSetCodec, index$e_tryAsLookupHistorySlots as tryAsLookupHistorySlots, index$e_tryAsPerCore as tryAsPerCore, index$e_validatorsDataCodec as validatorsDataCodec, index$e_workReportsSortedSetCodec as workReportsSortedSetCodec, index$e_zeroSizeHint as zeroSizeHint };
+  export { index$e_AccumulationOutput as AccumulationOutput, index$e_AvailabilityAssignment as AvailabilityAssignment, index$e_BASE_SERVICE_BALANCE as BASE_SERVICE_BALANCE, index$e_BlockState as BlockState, index$e_CoreStatistics as CoreStatistics, index$e_DisputesRecords as DisputesRecords, index$e_ELECTIVE_BYTE_BALANCE as ELECTIVE_BYTE_BALANCE, index$e_ELECTIVE_ITEM_BALANCE as ELECTIVE_ITEM_BALANCE, index$e_InMemoryService as InMemoryService, index$e_InMemoryState as InMemoryState, index$e_LookupHistoryItem as LookupHistoryItem, index$e_MAX_LOOKUP_HISTORY_SLOTS as MAX_LOOKUP_HISTORY_SLOTS, index$e_NotYetAccumulatedReport as NotYetAccumulatedReport, index$e_PreimageItem as PreimageItem, index$e_PrivilegedServices as PrivilegedServices, index$e_RecentBlocks as RecentBlocks, index$e_SafroleData as SafroleData, index$e_SafroleSealingKeysData as SafroleSealingKeysData, index$e_SafroleSealingKeysKind as SafroleSealingKeysKind, index$e_ServiceAccountInfo as ServiceAccountInfo, index$e_ServiceStatistics as ServiceStatistics, index$e_StatisticsData as StatisticsData, index$e_StorageItem as StorageItem, index$e_UpdateError as UpdateError, index$e_UpdatePreimage as UpdatePreimage, index$e_UpdatePreimageKind as UpdatePreimageKind, index$e_UpdateService as UpdateService, index$e_UpdateServiceKind as UpdateServiceKind, index$e_UpdateStorage as UpdateStorage, index$e_UpdateStorageKind as UpdateStorageKind, index$e_ValidatorData as ValidatorData, index$e_ValidatorStatistics as ValidatorStatistics, index$e_accumulationOutputComparator as accumulationOutputComparator, index$e_accumulationQueueCodec as accumulationQueueCodec, index$e_authPoolsCodec as authPoolsCodec, index$e_authQueuesCodec as authQueuesCodec, index$e_availabilityAssignmentsCodec as availabilityAssignmentsCodec, index$e_codecBandersnatchKey as codecBandersnatchKey, index$e_codecPerCore as codecPerCore, index$e_codecServiceId as codecServiceId, index$e_codecVarGas as codecVarGas, index$e_codecVarU16 as codecVarU16, index$e_codecWithVersion as codecWithVersion, index$e_hashComparator as hashComparator, index$e_ignoreValueWithDefault as ignoreValueWithDefault, index$e_recentlyAccumulatedCodec as recentlyAccumulatedCodec, index$e_serviceDataCodec as serviceDataCodec, index$e_serviceEntriesCodec as serviceEntriesCodec, index$e_sortedSetCodec as sortedSetCodec, index$e_tryAsLookupHistorySlots as tryAsLookupHistorySlots, index$e_tryAsPerCore as tryAsPerCore, index$e_validatorsDataCodec as validatorsDataCodec, index$e_workReportsSortedSetCodec as workReportsSortedSetCodec, index$e_zeroSizeHint as zeroSizeHint };
   export type { index$e_AUTHORIZATION_QUEUE_SIZE as AUTHORIZATION_QUEUE_SIZE, index$e_AccumulationQueue as AccumulationQueue, index$e_AccumulationQueueView as AccumulationQueueView, index$e_AuthorizationPool as AuthorizationPool, index$e_AuthorizationQueue as AuthorizationQueue, index$e_AvailabilityAssignmentsView as AvailabilityAssignmentsView, index$e_BlocksState as BlocksState, index$e_ENTROPY_ENTRIES as ENTROPY_ENTRIES, index$e_EnumerableState as EnumerableState, index$e_FieldNames as FieldNames, index$e_InMemoryStateFields as InMemoryStateFields, index$e_LookupHistorySlots as LookupHistorySlots, index$e_MAX_AUTH_POOL_SIZE as MAX_AUTH_POOL_SIZE, index$e_MAX_RECENT_HISTORY as MAX_RECENT_HISTORY, index$e_PerCore as PerCore, index$e_RecentBlocksView as RecentBlocksView, index$e_RecentlyAccumulated as RecentlyAccumulated, index$e_RecentlyAccumulatedView as RecentlyAccumulatedView, index$e_SafroleDataView as SafroleDataView, index$e_SafroleSealingKeys as SafroleSealingKeys, index$e_Service as Service, index$e_ServiceAccountInfoView as ServiceAccountInfoView, index$e_ServiceData as ServiceData, index$e_ServiceEntries as ServiceEntries, index$e_ServicesUpdate as ServicesUpdate, index$e_State as State, index$e_StateView as StateView, index$e_StatisticsDataView as StatisticsDataView, index$e_StorageKey as StorageKey, index$e_VALIDATOR_META_BYTES as VALIDATOR_META_BYTES, index$e_ValidatorDataView as ValidatorDataView, index$e_WithStateView as WithStateView };
 }
 
@@ -14292,7 +14414,7 @@ interface PartialState {
     a: PerCore<ServiceId>,
     v: ServiceId | null,
     r: ServiceId | null,
-    z: [ServiceId, ServiceGas][],
+    z: Map<ServiceId, ServiceGas>,
   ): Result$2<OK, UpdatePrivilegesError>;
 
   /** Yield accumulation trie result hash. */
@@ -14334,48 +14456,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;
 
@@ -14385,6 +14592,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);
@@ -14395,10 +14611,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);
@@ -14447,1493 +14659,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;
-
-  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);
-  }
+/** 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));
 
-  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[] = [];
 
-      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;
+    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.ONE_REGISTER_ONE_IMMEDIATE: {
-        const firstByte = this.code[pc + 1];
-        this.nibblesDecoder.setByte(firstByte);
-        result.registerIndex = this.nibblesDecoder.getLowNibbleAsRegisterIndex();
+      const page = this.memory.get(pageNumber);
 
-        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;
+      if (page === undefined) {
+        return Result.error(PageFault.fromPageNumber(pageNumber), () => `Page fault: page ${pageNumber} not allocated`);
       }
 
-      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),
+      if (accessType === AccessType.WRITE && !page.isWriteable()) {
+        return Result.error(
+          PageFault.fromPageNumber(pageNumber, true),
+          () => `Page fault: attempted to write to read-only page ${pageNumber}`,
         );
-        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();
+      pages.push(page);
+    }
 
-        const firstImmediateLength = this.nibblesDecoder.getHighNibbleAsLength();
-        const firstImmediateStartIndex = pc + 2;
-        const firstImmediateEndIndex = firstImmediateStartIndex + firstImmediateLength;
-        const firstImmediateBytes = this.code.subarray(firstImmediateStartIndex, firstImmediateEndIndex);
-        result.firstImmediateDecoder.setBytes(firstImmediateBytes);
+    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);
+    }
 
-        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;
-      }
+    const pagesResult = this.getPages(startAddress, result.length, AccessType.READ);
 
-      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();
+    if (pagesResult.isError) {
+      return Result.error(pagesResult.error, pagesResult.details);
+    }
 
-        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 pages = pagesResult.ok;
 
-        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;
-      }
+    let currentPosition: number = startAddress;
+    let bytesLeft = result.length;
 
-      case ArgumentType.ONE_REGISTER_ONE_EXTENDED_WIDTH_IMMEDIATE: {
-        const firstByte = this.code[pc + 1];
-        this.nibblesDecoder.setByte(firstByte);
-        result.registerIndex = this.nibblesDecoder.getLowNibbleAsRegisterIndex();
+    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);
 
-        const immediateStartIndex = pc + 2;
-        const immediateEndIndex = immediateStartIndex + 8;
-        const immediateBytes = this.code.subarray(immediateStartIndex, immediateEndIndex);
-        result.immediateDecoder.setBytes(immediateBytes);
-        break;
-      }
+      page.loadInto(destination, pageStartIndex, bytesToRead);
+
+      currentPosition += bytesToRead;
+      bytesLeft -= bytesToRead;
     }
+
+    logger.insane`MEM[${startAddress}] => ${BytesBlob.blobFrom(result)}`;
+    return Result.ok(OK);
   }
-}
 
-declare const createResults = () => {
-  const results = new Array(ARGUMENT_TYPE_LENGTH) as Results;
+  sbrk(length: number): SbrkIndex {
+    const currentSbrkIndex = this.sbrkIndex;
+    const currentVirtualSbrkIndex = this.virtualSbrkIndex;
 
-  results[ArgumentType.NO_ARGUMENTS] = {
-    type: ArgumentType.NO_ARGUMENTS,
-    noOfBytesToSkip: 1,
-  };
+    // new sbrk index is bigger than 2 ** 32 or endHeapIndex
+    if (MAX_MEMORY_INDEX < currentVirtualSbrkIndex + length || currentVirtualSbrkIndex + length > this.endHeapIndex) {
+      throw new OutOfMemory();
+    }
 
-  results[ArgumentType.ONE_IMMEDIATE] = {
-    type: ArgumentType.ONE_IMMEDIATE,
-    noOfBytesToSkip: 1,
-    immediateDecoder: new ImmediateDecoder(),
-  };
+    const newVirtualSbrkIndex = tryAsSbrkIndex(this.virtualSbrkIndex + length);
 
-  results[ArgumentType.TWO_REGISTERS] = {
-    type: ArgumentType.TWO_REGISTERS,
-    noOfBytesToSkip: 1,
-    firstRegisterIndex: 0,
-    secondRegisterIndex: 0,
-  };
+    // no alllocation needed
+    if (newVirtualSbrkIndex <= currentSbrkIndex) {
+      this.virtualSbrkIndex = newVirtualSbrkIndex;
+      return currentVirtualSbrkIndex;
+    }
 
-  results[ArgumentType.THREE_REGISTERS] = {
-    type: ArgumentType.THREE_REGISTERS,
-    noOfBytesToSkip: 1,
-    firstRegisterIndex: 0,
-    secondRegisterIndex: 0,
-    thirdRegisterIndex: 0,
-  };
+    // 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.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET] = {
-    type: ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET,
-    noOfBytesToSkip: 1,
-    registerIndex: 0,
-    immediateDecoder: new ImmediateDecoder(),
-    nextPc: 0,
-  };
+    for (const pageNumber of rangeToAllocate) {
+      const page = new WriteablePage(pageNumber);
+      this.memory.set(pageNumber, page);
+    }
 
-  results[ArgumentType.TWO_REGISTERS_ONE_OFFSET] = {
-    type: ArgumentType.TWO_REGISTERS_ONE_OFFSET,
-    noOfBytesToSkip: 1,
-    firstRegisterIndex: 0,
-    secondRegisterIndex: 0,
-    nextPc: 0,
-  };
+    this.virtualSbrkIndex = newVirtualSbrkIndex;
+    this.sbrkIndex = newSbrkIndex;
+    return currentVirtualSbrkIndex;
+  }
 
-  results[ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE] = {
-    type: ArgumentType.TWO_REGISTERS_ONE_IMMEDIATE,
-    noOfBytesToSkip: 1,
-    firstRegisterIndex: 0,
-    secondRegisterIndex: 0,
-    immediateDecoder: new ImmediateDecoder(),
-  };
+  getPageDump(pageNumber: PageNumber) {
+    const page = this.memory.get(pageNumber);
+    return page?.getPageDump() ?? null;
+  }
 
-  results[ArgumentType.ONE_REGISTER_ONE_IMMEDIATE] = {
-    type: ArgumentType.ONE_REGISTER_ONE_IMMEDIATE,
-    noOfBytesToSkip: 1,
-    registerIndex: 0,
-    immediateDecoder: new ImmediateDecoder(),
-  };
+  getDirtyPages() {
+    return this.memory.keys();
+  }
+}
 
-  results[ArgumentType.ONE_REGISTER_TWO_IMMEDIATES] = {
-    type: ArgumentType.ONE_REGISTER_TWO_IMMEDIATES,
-    noOfBytesToSkip: 1,
-    registerIndex: 0,
-    firstImmediateDecoder: new ImmediateDecoder(),
-    secondImmediateDecoder: new ImmediateDecoder(),
-  };
+declare class MemoryBuilder {
+  private readonly initialMemory: Map<PageNumber, MemoryPage> = new Map();
+  private isFinalized = false;
 
-  results[ArgumentType.ONE_OFFSET] = {
-    type: ArgumentType.ONE_OFFSET,
-    noOfBytesToSkip: 1,
-    nextPc: 0,
-  };
+  private ensureNotFinalized() {
+    if (this.isFinalized) {
+      throw new FinalizedBuilderModification();
+    }
+  }
 
-  results[ArgumentType.TWO_IMMEDIATES] = {
-    type: ArgumentType.TWO_IMMEDIATES,
-    noOfBytesToSkip: 1,
-    firstImmediateDecoder: new ImmediateDecoder(),
-    secondImmediateDecoder: new ImmediateDecoder(),
-  };
+  private ensureNoReservedMemoryUsage(range: MemoryRange) {
+    if (range.overlapsWith(RESERVED_MEMORY_RANGE)) {
+      throw new ReservedMemoryFault();
+    }
+  }
 
-  results[ArgumentType.TWO_REGISTERS_TWO_IMMEDIATES] = {
-    type: ArgumentType.TWO_REGISTERS_TWO_IMMEDIATES,
-    noOfBytesToSkip: 1,
-    firstImmediateDecoder: new ImmediateDecoder(),
-    secondImmediateDecoder: new ImmediateDecoder(),
-    firstRegisterIndex: 0,
-    secondRegisterIndex: 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.ONE_REGISTER_ONE_EXTENDED_WIDTH_IMMEDIATE] = {
-    type: ArgumentType.ONE_REGISTER_ONE_EXTENDED_WIDTH_IMMEDIATE,
-    noOfBytesToSkip: 9,
-    registerIndex: 0,
-    immediateDecoder: new ExtendedWitdthImmediateDecoder(),
-  };
+    const length = end - start;
+    const range = MemoryRange.fromStartAndLength(start, length);
 
-  return results;
-};
+    this.ensureNoReservedMemoryUsage(range);
 
-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,
-}
+    const pages = Array.from(PageRange.fromMemoryRange(range));
+    const noOfPages = pages.length;
 
-declare const instructionArgumentTypeMap = (() => {
-  const instructionArgumentTypeMap = new Array<ArgumentType>(HIGHEST_INSTRUCTION_NUMBER + 1);
+    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);
+    }
 
-  instructionArgumentTypeMap[Instruction.TRAP] = ArgumentType.NO_ARGUMENTS;
-  instructionArgumentTypeMap[Instruction.FALLTHROUGH] = ArgumentType.NO_ARGUMENTS;
+    return this;
+  }
 
-  instructionArgumentTypeMap[Instruction.ECALLI] = ArgumentType.ONE_IMMEDIATE;
+  /**
+   * 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.LOAD_IMM_64] = ArgumentType.ONE_REGISTER_ONE_EXTENDED_WIDTH_IMMEDIATE;
+    const length = end - start;
+    const range = MemoryRange.fromStartAndLength(start, 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;
+    this.ensureNoReservedMemoryUsage(range);
 
-  instructionArgumentTypeMap[Instruction.JUMP] = ArgumentType.ONE_OFFSET;
+    const pages = Array.from(PageRange.fromMemoryRange(range));
+    const noOfPages = pages.length;
 
-  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;
+    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.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;
+    return this;
+  }
 
-  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;
+  /**
+   * 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_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)`
+ * 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 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;
+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>(),
-  ) {}
-
-  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
+  isInstruction(index: number) {
+    return this.lookupTableForward[index] === 0;
   }
 
-  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;
   }
 }
 
@@ -16918,7 +17493,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));
     }
   }
 }
@@ -17719,34 +18294,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;
@@ -17756,7 +18317,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;
@@ -17810,7 +18370,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();
@@ -17818,7 +18383,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);
@@ -17960,10 +18524,6 @@ declare class Interpreter {
     return this.status;
   }
 
-  getRegisters() {
-    return this.registers;
-  }
-
   getPC() {
     return this.pc;
   }
@@ -17972,24 +18532,6 @@ 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;
   }
@@ -17997,233 +18539,84 @@ declare class Interpreter {
   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[];
+  }
 
-  /**
-   * 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);
@@ -18233,7 +18626,7 @@ declare class InterpreterInstanceManager {
     });
   }
 
-  releaseInstance(pvm: Interpreter) {
+  releaseInstance(pvm: IPvmInterpreter) {
     const waiting = this.waitingQueue.shift();
     if (waiting !== undefined) {
       return waiting(pvm);
@@ -18276,21 +18669,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(maybeLength);
-      const startAddress = tryAsMemoryIndex(maybeAddress);
-      const loadResult = memory.loadInto(result, startAddress);
+      const result = safeAllocUint8Array(length);
+
+      const loadResult = memory.loadInto(result, address);
 
       if (loadResult.isError) {
         return ReturnValue.fromMemorySlice(gasConsumed, new Uint8Array());
@@ -18302,7 +18696,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();
@@ -18314,9 +18708,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);
@@ -18329,7 +18723,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);
@@ -18340,6 +18734,7 @@ declare class HostCalls {
         regs,
         gas.get(),
       );
+      pvmInstance.registers.setAllEncoded(regs.getEncoded());
 
       if (result === PvmExecution.Halt) {
         status = Status.HALT;
@@ -18366,15 +18761,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 {
@@ -18383,20 +18772,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 };
 }
 
 /**
@@ -18414,7 +18801,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,
@@ -18442,7 +18829,7 @@ type MachineStatus =
 type MachineResult = {
   result: MachineStatus;
   gas: BigGas;
-  registers: Registers;
+  registers: HostCallRegisters;
 };
 
 /** Types of possbile operations to request by Pages host call. */
@@ -18514,7 +18901,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. */
@@ -18523,7 +18910,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. */
@@ -18533,7 +18920,7 @@ interface RefineExternalities {
   machineInvoke(
     machineIndex: MachineId,
     gas: BigGas,
-    registers: Registers,
+    registers: HostCallRegisters,
   ): Promise<Result$2<MachineResult, NoMachineError>>;
 
   /**
@@ -18955,7 +19342,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);
@@ -18986,270 +19373,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 {
@@ -19265,11 +19457,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 {
@@ -19292,7 +19484,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 {
@@ -19319,11 +19511,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 {
@@ -19335,11 +19527,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));
   }
 }
 
@@ -19366,8 +19558,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;
@@ -19450,6 +19640,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;
@@ -19457,6 +19648,7 @@ declare const index$3_inspect: typeof inspect;
 declare const index$3_instructionArgumentTypeMap: typeof instructionArgumentTypeMap;
 declare const index$3_isBrowser: typeof isBrowser;
 declare const index$3_isTaggedError: typeof isTaggedError;
+declare const index$3_lazyInspect: typeof lazyInspect;
 declare const index$3_maybeTaggedErrorToString: typeof maybeTaggedErrorToString;
 declare const index$3_measure: typeof measure;
 declare const index$3_preimageLenAsU32: typeof preimageLenAsU32;
@@ -19468,8 +19660,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_lazyInspect as lazyInspect, 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;
@@ -20062,10 +20254,10 @@ declare const fullStateDumpFromJson = (spec: ChainSpec) =>
         chi_v: "number",
         chi_r: json.optional("number"),
         chi_g: json.nullable(
-          json.array({
-            service: "number",
-            gasLimit: json.fromNumber((v) => tryAsServiceGas(v)),
-          }),
+          json.map(
+            "number",
+            json.fromNumber((v) => tryAsServiceGas(v)),
+          ),
         ),
       },
       pi: JsonStatisticsData.fromJson,
@@ -20132,7 +20324,7 @@ declare const fullStateDumpFromJson = (spec: ChainSpec) =>
           assigners: chi.chi_a,
           delegator: chi.chi_v,
           registrar: chi.chi_r ?? tryAsServiceId(2 ** 32 - 1),
-          autoAccumulateServices: chi.chi_g ?? [],
+          autoAccumulateServices: chi.chi_g ?? new Map(),
         }),
         statistics: JsonStatisticsData.toStatisticsData(spec, pi),
         accumulationQueue: omega,
@@ -20361,4 +20553,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 };